淺談Synchronized:

synchronized是Java的一個關鍵字,也就是Java語言內建的特性,如果一個程式碼塊被synchronized修飾了,當一個執行緒獲取了對應的鎖,執行程式碼塊時,其他執行緒
便只能一直等待,等待獲取鎖的執行緒釋放鎖,而獲取鎖的執行緒釋放鎖會有三種情況:
1).獲取鎖的執行緒執行完該程式碼塊,然後執行緒釋放對鎖的佔有;
2).執行緒執行發生異常,此時JVM會讓執行緒自動釋放鎖;
3).呼叫wait方法,在等待的時候立即釋放鎖,方便其他的執行緒使用鎖.

Lock的特性:

1).Lock不是Java語言內建的;
2).synchronized是在JVM層面上實現的,如果程式碼執行出現異常,JVM會自動釋放鎖,但是Lock不行,要保證鎖一定會被釋放,就必須將unLock放到finally{}中(手動釋放);
3).在資源競爭不是很激烈的情況下,Synchronized的效能要優於ReetarntLock,但是在很激烈的情況下,synchronized的效能會下降幾十倍;
4).ReentrantLock增加了鎖:
a. void lock(); // 無條件的鎖;
b. void lockInterruptibly throws InterruptedException;//可中斷的鎖;
解釋:　　使用ReentrantLock如果獲取了鎖立即返回,如果沒有獲取鎖,當前執行緒處於休眠狀態,直到獲得鎖或者當前執行緒可以被別的執行緒中斷去做其他的事情;但是如果是synchronized的話,如果沒有獲取到鎖,則會一直等待下去;
c. boolean tryLock();//如果獲取了鎖立即返回true,如果別的執行緒正持有,立即返回false,不會等待;
d. boolean tryLock(long timeout,TimeUnit unit);//如果獲取了鎖立即返回true,如果別的執行緒正持有鎖,會等待引數給的時間,在等待的過程中,如果獲取鎖,則返回true,如果等待超時,返回false;
5）Lock的ReentrantReadWriteLock讀寫鎖 適用於 讀多寫少的場景 效率較高

Condition的特性:

1.Condition中的await()方法相當於Object的wait()方法，Condition中的signal()方法相當於Object的notify()方法，Condition中的signalAll()相當於Object的notifyAll()方法。不同的是，Object中的這些方法是和同步鎖捆綁使用的；而Condition是需要與互斥鎖/共享鎖捆綁使用的。
2.Condition它更強大的地方在於：能夠更加精細的控制多執行緒的休眠與喚醒。對於同一個鎖，我們可以建立多個Condition，在不同的情況下使用不同的Condition。
　　　　例如，假如多執行緒讀/寫同一個緩衝區：當向緩衝區中寫入資料之後，喚醒”讀執行緒”；當從緩衝區讀出資料之後，喚醒”寫執行緒”；並且當緩衝區滿的時候，”寫執行緒”需要等待；當緩衝區為空時，”讀執行緒”需要等待。
如果採用Object類中的wait(), notify(), notifyAll()實現該緩衝區，當向緩衝區寫入資料之後需要喚醒”讀執行緒”時，不可能通過notify()或notifyAll()明確的指定喚醒”讀執行緒”，而只能通過notifyAll喚醒所有執行緒(但是notifyAll無法區分喚醒的執行緒是讀執行緒，還是寫執行緒)。 但是，通過Condition，就能明確的指定喚醒讀執行緒。

例項

ListAdd.java 使用synchronized

package ThreadCollections;


import java.util.ArrayList;
import java.util.List;

/**
 * Created by 胖大星 on 2017/9/12.
 */
public class ListAdd {
   private volatile static  List list = new ArrayList();

   public void addList(){
       list.add("hello");
   }

   public
 
 int size(){
       return list.size();
   }

   public static void main(String[] agrs){
       final ListAdd list1 = new ListAdd();
       Object lock = new Object();
       Thread thread = new Thread(new Runnable(){
           @Override
           public void run() {
                   try {
                       synchronized (lock){
                           for (int i = 0; i < 10; i++) {
                               list1.addList();
                               System.out.println("當前執行緒為： "+Thread.currentThread().getName()+"  "+i);
                               Thread.sleep(500);
                               if(list.size() == 5){
                                   System.out.println("當前通知已發出！");
                                   lock.notify();
                               }
                           }
                       }
                   }
                   catch (InterruptedException e){
                        e.printStackTrace();
                   }
           }
       },"t1");

       Thread thread2 = new Thread(new Runnable() {
           @Override
           public void run() {
               synchronized (lock) {
                   if (list1.size() != 5) {
                       try {
                            lock.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
                   System.out.println("當前執行緒：" + Thread.currentThread().getName()+"已經收到通知");
                   throw new RuntimeException();
               }
           }
       },"t2");

       thread2.start();
       thread.start();

   }
}

UseReentrantLock.java 使用Lock

package Lock;

import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by 胖大星 on 2017/9/17.
 * Lock 比 synchronized 方法更加便捷，靈活
 */
public class UseReentrantLock {
    //new ReentrantLock(false) 可以帶引數 false 表示非公平鎖（根據cpu分配優先執行） true表示公平鎖（先來先執行）
    private ReentrantLock lock = new ReentrantLock();
    public void method1(){
        try {
            lock.lock();
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入method1...");
            Thread.sleep(1000);
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"退出method1...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void method2(){
        try {
            lock.lock();
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入method2...");
            Thread.sleep(1000);
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"退出method2...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        UseReentrantLock useReentrantLock = new UseReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                useReentrantLock.method1();
                useReentrantLock.method2();
            }
        }, "t1");

        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

UseManyCondition.java 使用多個Condition

package Lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * Created by 胖大星 on 2017/9/17.
 *啟動多個 Condition 並行鎖  同時並行多個執行緒
 */
public class UseManyCondition {

    private ReentrantLock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();

    public void m1(){
        try {
            lock.lock();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "進入方法m1等待..");
            c1.await();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "方法m1繼續..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m2(){
        try {
            lock.lock();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "進入方法m2等待..");
            c1.await();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "方法m2繼續..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m3(){
        try {
            lock.lock();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "進入方法m3等待..");
            c2.await();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "方法m3繼續..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m4(){
        try {
            lock.lock();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "喚醒..");
            c1.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void m5(){
        try {
            lock.lock();
            System.out.println("當前執行緒：" +Thread.currentThread().getName() + "喚醒..");
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {


        final UseManyCondition umc = new UseManyCondition();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m2();
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m3();
            }
        },"t3");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m4();
            }
        },"t4");
        Thread t5 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m5();
            }
        },"t5");

        t1.start(); // c1
        t2.start(); // c1
        t3.start(); // c2


        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t4.start(); // c1
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t5.start(); // c2

    }



}

UseReentrantReadWriteLock.java Lock使用讀寫鎖

package Lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by 胖大星 on 2017/9/17.
 * lock的ReentrantReadWriteLock讀寫鎖  適用於 讀多寫少的場景 效率較高
 */
public class UseReentrantReadWriteLock {
    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();

    public void read(){
        try {
            readLock.lock();
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入....");
            Thread.sleep(3000);
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"退出....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            readLock.unlock();
        }
    }

    public void write(){
        try {
            writeLock.lock();
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"進入....");
            Thread.sleep(3000);
            System.out.println("當前執行緒："+Thread.currentThread().getName()+"退出....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            writeLock.unlock();
        }
    }

    public static void main(String[] args) {
        UseReentrantReadWriteLock useReentrantReadWriteLock = new UseReentrantReadWriteLock();
        Thread threadRead1 = new Thread(new Runnable() {
            @Override
            public void run() {
                useReentrantReadWriteLock.read();
            }
        }, "threadRead1");
      Thread threadRead2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    useReentrantReadWriteLock.read();
                }
            }, "threadRead2");

        Thread threadWrite1 = new Thread(new Runnable() {
            @Override
            public void run() {
                useReentrantReadWriteLock.write();
            }
        }, "threafWrite1");

        Thread threadWrite2 = new Thread(new Runnable() {
            @Override
            public void run() {
                useReentrantReadWriteLock.write();
            }
        }, "threafWrite2");

        //兩個讀執行緒同時開始 ，寫執行緒明顯較慢
        threadRead1.start();
       // threadRead2.start();
        threadWrite1.start();
      //  threadWrite2.start();
    }
}