synchronized 和 ReentrantLock

JDK5.0 开始,有两种机制来保护代码块不受并行访问的干扰.从旧版本的java用的synchronized 关键字达到这个目的,而JDK5.0引进勒ReentrantLock类。在测试线程的并行访问时,不同线程中调用的是同一个加锁对象所在类的实例。不同的实例，会得到不同的锁对象,最终结果是互不干扰。

Synchronized 关键字:
      java中两种使用synchronized的方式:同步代码块,同步方法.
      synchronized(obj)表示若多个线程同时访问时,只让其中一个线程最先取得obj对象对其加锁。其他线程则阻塞直到取得obj对象的线程执行代码块,此时被加锁的obj对象得到释放(解锁),其他线程得到通知取得该锁的obj对象。继续执行！
      很多情况可以使用synchronized(this){..}来同步代码块，但需要注意的是，使用this作为同步对象的话,如果同一个类中存在多个synchronized(this){..}代码块,其中任何一个synchronized(this)代码块处于被执行状态，则其他线程对其他synchronized(this){..}代码块的访问也会受到阻塞。
      需注意:同步代码块synchonized(this){}的多线程阻塞问题(包括synchronized同步方法),在并发处理的系统中(比如WEB服务器)会严重影响性能，建议慎重使用。可以使用sychronized(obj){..}缩小同步资源对象的范围来解决这个问题!

package com.mz.xx.tb;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SynchronizedTest{

    private Lock myLock = new ReentrantLock();
    
    /**
     * 第一种形式 同步方法
     */
    
//    synchronized public void synchronized_Test1(){
//        for(int i = 0;i<10;i++){
//            try {
//                Thread.sleep(2000);
//            } catch (InterruptedException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//        System.out.println("Synchronized way--"+Thread.currentThread().getName()+": "+i);
//        }
//    }
    
    /**
     * 第二种形式 同步代码块
     */

     public void synchronized_Test2(){
         synchronized (this) {
             for(int i = 0;i<10;i++){
                 try {
                     Thread.sleep(2000);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
                 System.out.println("Synchronized way--"+Thread.currentThread().getName()+": "+i);
             }
        }
    }
    

     /**
     * 通过ReentrantLock同步代码块
     */
     public void reentrantLock_Test(){
         myLock.lock();//加锁
            try {
                for(int i = 0;i<10;i++){
                        Thread.sleep(2000);
                        System.out.println("ReentrantLock way--"+Thread.currentThread().getName()+": "+i);
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                myLock.unlock();//解锁
            }
    }
     
     
    public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
//        String waysName = "Synchronized";
        String waysName = "ReentruntLockTest";
        Thread t1 = new Thread(new Demo(synchronizedTest,waysName));
        Thread t2 = new Thread(new Demo(synchronizedTest,waysName));
        t1.start();
        t2.start();
    }
    
}
class Demo implements Runnable{
    
    private SynchronizedTest synchronizedTest;
    private String waysName;
    
    public Demo(SynchronizedTest synchronizedTest,String waysName) {
        super();
        this.synchronizedTest = synchronizedTest;
        this.waysName = waysName;
    }


    public void run() {
        if(waysName.equals("Synchronized")){
//            synchronizedTest.synchronized_Test1();
            synchronizedTest.synchronized_Test2();
        }else if(waysName.equals("ReentruntLockTest")){
            synchronizedTest.reentrantLock_Test();
        }
    }
    
}