一、什麼是sychronized

       sychronized是java中最基本同步互斥的手段,可以修飾程式碼塊,方法,類.

      在修飾程式碼塊的時候需要一個reference物件作為鎖的物件.

      在修飾方法的時候預設是當前物件作為鎖的物件.

      在修飾類時候預設是當前類的Class物件作為鎖的物件.

      synchronized會在進入同步塊的前後分別形成monitorenter和monitorexit位元組碼指令.在執行monitorenter指令時會嘗試獲取物件的鎖,如果此沒物件沒有被鎖,或者此物件已經被當前執行緒鎖住,那麼鎖的計數器加一,每當monitorexit被鎖的物件的計數器減一.直到為0就釋放該物件的鎖.由此synchronized是可重入的,不會出現自己把自己鎖死.

二、什麼ReentrantLock

      以物件的方式來操作物件鎖.相對於sychronized需要在finally中去釋放鎖。

三、synchronized和ReentrantLock的區別

     1. 等待可中斷

     在持有鎖的執行緒長時間不釋放鎖的時候,等待的執行緒可以選擇放棄等待.   tryLock(long timeout, TimeUnit unit)。

     ReentrantLock 擁有Synchronized相同的併發性和記憶體語義，此外還多了 鎖投票，定時鎖等候和中斷鎖等候。

 執行緒A和B都要獲取物件O的鎖定，假設A獲取了物件O鎖，B將等待A釋放對O的鎖定。

  如果使用 synchronized ，如果A不釋放，B將一直等下去，不能被中斷。

  如果使用ReentrantLock，如果A不釋放，可以使B在等待了足夠長的時間以後，中斷等待，而幹別的事情。

  ReentrantLock獲取鎖定與三種方式： 
        a)  lock(), 如果獲取了鎖立即返回，如果別的執行緒持有鎖，當前執行緒則一直處於休眠狀態，直到獲取鎖

    b) tryLock(), 如果獲取了鎖立即返回true，如果別的執行緒正持有鎖，立即返回false；

    c) tryLock (long timeout, TimeUnit  unit)，   如果獲取了鎖定立即返回true，如果別的執行緒正持有鎖，會等待引數給定的時間，在等待的過程中，如果獲取了鎖定，就返回true，如果等待超時，返回false；

    d) lockInterruptibly: 如果獲取了鎖定立即返回，如果沒有獲取鎖定，當前執行緒處於休眠狀態，直到或者鎖定，或者當前執行緒被別的執行緒中斷

    2.公平鎖與非公平鎖

        按照申請鎖的順序來一次獲得鎖稱為公平鎖.synchronized的是非公平鎖,ReentrantLock可以通過建構函式實現公平鎖.    new RenentrantLock(boolean fair)

        3.繫結多個Condition

        通過多次newCondition可以獲得多個Condition物件,可以簡單的實現比較複雜的執行緒同步的功能.通過await(),signal()

        此外，synchronized是在JVM層面上實現的，不但可以通過一些監控工具監控synchronized的鎖定，而且在程式碼執行時出現異常，JVM會自動釋放鎖定，但是使用Lock則不行，lock是通過程式碼實現的，要保證鎖定一定會被釋放，就必須將 unLock()放到finally{} 中。在資源競爭不是很激烈的情況下，Synchronized的效能要優於ReetrantLock，但是在資源競爭很激烈的情況下，Synchronized的效能會下降幾十倍，但是ReetrantLock的效能能維持常態。

四、例項演示

      ReentrantLock 的lock機制有2種，忽略中斷鎖和響應中斷鎖，這給我們帶來了很大的靈活性。比如：如果A、B兩個執行緒去競爭鎖，A執行緒得到了鎖，B執行緒等待，但是A執行緒這個時候實在有太多事情要處理，就是一直不返回，B執行緒可能就會等不及了，想中斷自己，不再等待這個鎖了，轉而處理其他事情。這個時候ReentrantLock就提供了兩種機制：

       一、B執行緒中斷自己（或者別的執行緒中斷它），但ReentrantLock 不去響應，讓B執行緒繼續等待，你再怎麼中斷，我全當耳邊風（synchronized原語就是如此）；

       二、B執行緒中斷自己（或者別的執行緒中斷它），ReentrantLock 處理了這個中斷，並且不再等待這個鎖的到來，完全放棄。

      請看例子：

package zmx.multithread.test.reentrantlock;

import java.util.concurrent.locks.ReentrantLock;


/**
 * 
 * @author zhangwenchao
 *
 */

public class ReentrantLockTest {
    //是用ReentrantLock，還是用synchronized
	
    public static boolean useSynchronized = false;
    
    public static void main(String[] args) {
        IBuffer buff = null;
        if(useSynchronized){
            buff = new Buffer();
        }else{
            buff = new BufferInterruptibly();    
        }
        final Writer writer = new Writer(buff);
        final Reader reader = new Reader(buff);
        writer.start();
        reader.start();
        new Thread(new Runnable() {
            public void run() {
                long start = System.currentTimeMillis();
                for (;;) {
                    // 等5秒鐘去中斷讀
                    if (System.currentTimeMillis() - start > 5000) {
                        System.out.println("不等了，嘗試中斷");
                        reader.interrupt();
                        break;
                    }

                }

            }
        }).start();
    }
}

interface IBuffer{
    public void write();
    public void read() throws InterruptedException;
}

class Buffer implements IBuffer{
    private Object lock;

    public Buffer() {
        lock = this;
    }

    public void write() {
        synchronized (lock) {
            long startTime = System.currentTimeMillis();
            System.out.println("開始往這個buff寫入資料…");
            for (;;)// 模擬要處理很長時間
            {
                if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE)
                    break;
            }
            System.out.println("終於寫完了");
        }
    }

    public void read() {
        synchronized (lock) {
            System.out.println("從這個buff讀資料");
        }
    }
}

class BufferInterruptibly implements IBuffer{

    private ReentrantLock lock = new ReentrantLock();

    public void write() {
        lock.lock();
        try {
            long startTime = System.currentTimeMillis();
            System.out.println("開始往這個buff寫入資料…");
            for (;;)// 模擬要處理很長時間
            {
                if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE)
                    break;
            }
            System.out.println("終於寫完了");
        } finally {
            lock.unlock();
        }
    }

    public void read() throws InterruptedException{
        lock.lockInterruptibly();// 注意這裡，可以響應中斷
       // lock.lock();// 注意這裡，不可以響應中斷
        try {
            System.out.println("從這個buff讀資料");
        } finally {
            lock.unlock();
        }
    }

}

class Writer extends Thread {

    private IBuffer buff;

    public Writer(IBuffer buff) {
        this.buff = buff;
    }

    @Override
    public void run() {
        buff.write();
    }

}

class Reader extends Thread {

    private IBuffer buff;

    public Reader(IBuffer buff) {
        this.buff = buff;
    }

    @Override
    public void run() {

        try {
            buff.read();
        } catch (InterruptedException e) {
            System.out.println("我不讀了");   
        }

        System.out.println("讀結束");

    }
}

      1) 如果使用lock.lockInterruptibly();指定可以響應中斷，則輸出如下：

開始往這個buff寫入資料…
不等了，嘗試中斷
我不讀了
讀結束

      則：獲取到中斷異常，執行中斷異常處理程式。

     2) 如果使用lock.lock();指定不可以響應中斷，則輸出如下：

開始往這個buff寫入資料…
不等了，嘗試中斷

     則：不能獲取到中斷異常，執行緒等待。

    示例二：

package zmx.multithread.test.reentrantlock;

import java.util.concurrent.TimeUnit;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
public class T2{  
    public static void main(String[] args){    
        Thread i1 = new Thread(new RunIt3());  
        Thread i2 = new Thread(new RunIt3());  
        i1.start();  
        i2.start();  
        i2.interrupt();  //中斷
    }  
  }  
 
class RunIt3 implements Runnable{  
  
    private static Lock lock = new ReentrantLock();  
    public void run(){  
        try{  
            //---------a--------------------------  
            //lock.lock();            
            lock.lockInterruptibly(); 
            //lock.tryLock();
            //lock.tryLock(5,TimeUnit.SECONDS); 
            System.out.println(Thread.currentThread().getName() + " running");  
            TimeUnit.SECONDS.sleep(10);             
            System.out.println(Thread.currentThread().getName() + " finished"); 
            lock.unlock();
            
        }catch (InterruptedException e){  
            System.out.println(Thread.currentThread().getName() + " interrupted");  
  
        }  
  
    }  
} 

    如果a處是lock.lock(); 輸出: 
Thread-0 running 
(這裡休眠了10s) 
Thread-0 finished 
Thread-1 running 
Thread-1 interrupted 
============================ 
    如果a處是lock.lockInterruptibly();輸出： 
Thread-0 running 
Thread-1 interrupted 
(這裡休眠了10s) 
Thread-0 finished