1：鎖（Lock）

　　1.1 java提供了一個鎖的接口，這個鎖同樣可以達到同步代碼塊的功能，API文檔上說使用鎖比使用synchronized更加靈活。

　　1.2 如何使用這個“鎖”

　　　　//1.創建一個所對象，我們可以理解為寫一個synchronized代碼塊

　　　　public static Lock lock = new ReentrantLock();//用lock的一個子類去創建

　　　　//2.假設有某程序中使用兩把鎖，這兩把鎖是類似于synchronized里的鎖

　　　　//要使用到Condition類，中文：條件、情況、制約、限制的意思，在API文檔總稱之為“條件、條件列隊或者條件變量”

　　　　 public static Condition notFull = lock.newCondition();//Condition

　　　　public static Condition notEmpty = lock.newCondition();

　　1.3 Condition 將 Object 監視器方法（wait、notify 和 notifyAll）分解成截然不同的對象，以便通過將這些對象與任意 Lock 實現組合使用，為每個對象提供多個等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監視器方法的使用。（摘自文檔，重點是最后一句）

　　1.4 重要方法（Condition的）：

　　　　　　await()：等候，調用此方法線程將釋放鎖，進入等待狀態

　　　　　　signal()：中文：信號、發信號。調用此方法可以喚醒一個等待總的線程

　　　　　　signalAll()：喚醒所有在等待重點的線程

1.5 使用Lock和Condition的生產和消費的代碼。

  1 package com.java.lock;  2   3 import java.util.ArrayList;  4 import java.util.List;  5 import java.util.concurrent.locks.Condition;  6 import java.util.concurrent.locks.Lock;  7 import java.util.concurrent.locks.ReentrantLock;  8   9 public class PRoduceCustomerDemo1 { 10  11     public static void main(String[] args) { 12         Produce p1 = new Produce(); 13         p1.setName("生產者1"); 14         Produce p2 = new Produce(); 15         p2.setName("生產者2"); 16         Produce p3 = new Produce(); 17         p3.setName("生產者3"); 18         Customer c1 = new Customer(); 19         c1.setName("消費者1"); 20         Customer c2 = new Customer(); 21         c2.setName("消費者2"); 22         Customer c3 = new Customer(); 23         c3.setName("消費者3"); 24         p1.start(); 25         p2.start(); 26         c1.start(); 27         c2.start(); 28         p3.start(); 29         c3.start(); 30     } 31 } 32  33 class MyLock { 34     public static Lock lock = new ReentrantLock(); 35     public static Condition notFull = lock.newCondition(); 36     public static Condition notEmpty = lock.newCondition(); 37     public static int num;// 編號 38     public static int sum;// 庫存 39     public static Object obj = new Object(); 40     public static List<Integer> list = new ArrayList<Integer>(); 41 } 42  43 class Produce extends Thread { 44     @Override 45     public void run() { 46         while (true) { 47             //同步開始的標志，這里代替了synchronized 48             MyLock.lock.lock(); 49             while (MyLock.sum >= 6) {// 在多個消費者操作這個數據時，每次都要判斷而且是循環判斷 50                 try { 51                     //notFull，調用await()方法進入等待狀態，前提是sum》=6 52                     MyLock.notFull.await(); 53                 } catch (InterruptedException e) { 54                     e.printStackTrace(); 55                 } 56             } 57  58             MyLock.sum++; 59             MyLock.num++; 60             MyLock.list.add(MyLock.num); 61             try { 62                 Thread.sleep(100); 63             } catch (InterruptedException e) { 64                 e.printStackTrace(); 65             } 66             System.out.println(Thread.currentThread().getName() + "生產了一個產品，編號：" 67                     + MyLock.num + "，現有：" + MyLock.sum + "個"); 68             //調用signal()方法將等待中的線程喚醒，也可以使用signalAll()方法 69             MyLock.notEmpty.signal(); 70             //同步結束的標志 71             MyLock.lock.unlock(); 72         } 73     } 74 } 75  76 class Customer extends Thread { 77  78     @Override 79     public void run() { 80         while (true) { 81             //同步代碼塊開始 82             MyLock.lock.lock(); 83             while (MyLock.sum == 0) { 84                 try { 85                     //進入線程等待狀態，前提是sum==0 86                     MyLock.notEmpty.await(); 87                 } catch (InterruptedException e) { 88                     e.printStackTrace(); 89                 } 90             } 91             int ran = (int) (Math.random() * MyLock.sum); 92             MyLock.sum--; 93             try { 94                 Thread.sleep(100); 95             } catch (InterruptedException e) { 96                 e.printStackTrace(); 97             } 98             int number = MyLock.list.remove(ran); 99             System.out.println(Thread.currentThread().getName() + "消費了一個包子，編號："100                     + number + "，現有：" + MyLock.sum + "個");101             //喚醒等待中的一個線程102             MyLock.notFull.signal();103             //同步代碼塊結束104             MyLock.lock.unlock();105         }106     }107 108 }

2：線程池.

2.1:為什么會出現線程池。

線程的總時間=啟動線程的時間t1+執行run方法的時間t2+銷毀線程的時間t3。

如果t1+t3>t2時。這個時候應該減少啟動線程和銷毀線程的次數以節省時間。線程池可以解決這個問題。創建線程池，先啟動固定個數的線程，讓這些線程去執行任務，當一個線程執行完一個任務后，它會處于空閑狀態，如果還有任務，它會繼續執行其他的任務。當所有的任務執行完后，再銷毀線程池中的線程。

　　　　　　以上一段是網上找的，說的就是那么一回事，減少線程啟動和提高線程運行的質量，也提高了運行效率。現實中這種情況也很常見嘛。一個飯店，一般都有一大桶飯的吧，當有顧客來了，就可以直接在飯桶里盛飯給顧客了，如果你沒有一桶飯，那么每次有一個顧客來你都要單獨幫他煮一份，萬一顧客很多呢？這個飯店會有很多鍋用來煮飯嗎？即使煮好了碗，那顧客還有一碗，豈不是又要重新開鍋幫他煮一碗？這樣不合適吧，等飯的時間都比吃飯的時間要長咯。所以，飯店里準備著一大桶飯比較好。線程池就相當于這個飯桶，顧客相當于每個線程。鍋其實也可以理解為資源或者內存吧。線程池（飯桶）提高了線程運行（顧客吃飯）的效率了，也節省了線程的開啟關閉所占用的內存（鍋）。雖然這個例子沒有提到線程的關閉，但是這個例子就是這么一個意思。

只創建固定的線程。讓它執行更多的任務。請往下看線程池的創建。

2.2相關的類：（一般也就是這兩三個類就足夠了）

Executors（執行者）：此包中所定義的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 類的工廠和實用方法。 ExecutorService：一個接口

ThreadPoolExecutor：實現了ExecutorServer接口的一個子類

2.3線程池的創建以及使用線程池開啟線程。

 1 import java.util.concurrent.ExecutorService; 2 import java.util.concurrent.Executors; 3  4 public class ThreadPoolDemo1 { 5     public static void main(String[] args) { 6         /* 7          * 創建一個大小為 3 的線程池，newFixedThreadPool(int nThread) 8          * 意思是這個線程池中最多同時可運行三個線程，如果要想執行其他線程應該等待線程池池有線程結束 9          */10         ExecutorService executor = Executors.newFixedThreadPool(3);11         /*Produce p1 = new Produce();12         Customer c1 = new Customer();*/13         /*for(int i=0; i<3; i++){14             executor.execute(p1);15             executor.execute(c1);16         }*/17         //用循環來開啟三個線程,也可以手動一個個開啟18         for(int i=0; i<3; i++){19             executor.execute(new MyRunnable());20         }21         /*MyRunnable mr = new MyRunnable();22         executor.execute(mr);23         executor.execute(mr);24         executor.execute(mr);*/25         //線程執行完畢關閉線程池26         executor.shutdown();27     }28 }29 30 class MyRunnable implements Runnable{31 32     @Override33     public void run() {34         for(int i=0; i<10; i++){35             System.out.println(Thread.currentThread().getName()+":"+i);36         }37         38     }39     40 }

總結：以下是個人對線程的一下理解。

　　　　線程可以讓一個程序同時去執行多個任務，而不必等待前面的任務執行完才能執行下一個。好比車道：單條通道只能讓一輛車通過，多條車道能讓多輛車通過，通道就是線程，讓車通過就是任務，讓車通過的速度哪個快就很明顯了（前提是車的數量和車速不能相差太多）。線程是為了同步完成多項任務，不是為了提高運行效率，而是為了提高資源的使用效率從而提高了系統的效率。

　　　　當多線程操作同一個數據時就會發生線程安全問題，解決的方法就是實現線程的同步，同步有兩種方法，1：使用synchronized（同步）關鍵字，synchronized還可以分為synchronized方法和synchronized代碼塊；2：使用Lock，配合Condition對象。同步是解決的安全性問題，但是同時也帶來了兩個問題。1：執行效率下降；2：同步死鎖。死鎖在同步嵌套（同步中又有同步）發生。

　　　　線程太多，開啟和關閉用的時間就多了，為了提高線程運行的效率更高，用到了線程池。線程池使得線程的開啟和關閉的時間大大減少，提高了線程運行效率。