多線程學習之路-學習wait和notify

因爲工做須要，公司項目開始轉Java，大部分東西須要自學來完成，以前在網上看過好多視頻教程，其中有個做業是使用 wait notify 實現一個隊列，隊列有2個方法，put 和 take 。put方法往隊列中添加元素，take方法往隊列中得到元素。
隊列必須是線程安全的。若是put執行時，隊列爲空，線程必須阻塞等待，直到有隊列有數據。若是put時，隊列已經滿，則put線程要等待，直到隊列有空閒空間。網上找了好多答案，好多答案都是使用 ArrayBlockingQueue<Integer>實現的，
感受都不是很符合這個題目的要求，索性本身就摸索着
寫了一個例子；先說一下解題思路
1.首先定義一個普通的Java類
2.既然是隊列裏面必須申請一個list對應，這裏我用了LinkedList實現了List接口；
3.定義了List，就須要對list有添加和移除的方法，所以產生了put和take的兩個方法；put中判斷長度，大於定義長度則wait;小於則添加而且notify其餘線程；take操做相似；
4.多線程操做，確定須要一個對象鎖，所以聲明瞭類型爲Object的lock鎖；
5.做爲設置了List最大長度，所以申明瞭AtomicInteger的count對象，此時爲啥不用list.size()獲取長度，由於多線程的操做size沒有同步功能；
大概思路就是這樣，下面直接上代碼，代碼能夠直接運行的；內容是根據網絡視頻寫的，歡迎你們轉載學習交流；

 1 package threadtest;
 2 
 3 import java.util.LinkedList;
 4 import java.util.concurrent.TimeUnit;
 5 import java.util.concurrent.atomic.AtomicInteger;
 6 
 7 public class QueueTest01 {
 8     private LinkedList<Object> list = new LinkedList<Object>();
 9     private AtomicInteger count = new AtomicInteger(0);
10     private final int minSize = 0;
11     private final int maxSize;
12 
13     public QueueTest01(int maxsize) {
14         this.maxSize = maxsize;
15     }
16 
17     private final Object lock = new Object();
18 
19     public void put(Object obj) {
20         synchronized (lock) {
21             while (this.maxSize == count.get()) {
22                 try {
23                     lock.wait();
24                 } catch (InterruptedException e) {
25                     // TODO Auto-generated catch block
26                     e.printStackTrace();
27                 }
28             }
29             list.add(obj);
30             count.incrementAndGet();
31             System.out.println("新加入的元素是：" + obj);
32             lock.notify();
33         }
34     }
35 
36     public Object take() {
37         Object obj = null;
38         synchronized (lock) {
39             while (this.minSize == count.get()) {
40                 try {
41                     lock.wait();
42                 } catch (InterruptedException e) {
43                     // TODO Auto-generated catch block
44                     e.printStackTrace();
45                 }
46             }
47             obj = list.removeFirst();
48             count.decrementAndGet();
49             lock.notify();
50         }
51         return obj;
52     }
53 
54     public static void main(String[] args) {
55         final QueueTest01 myQueue = new QueueTest01(5);
56         myQueue.put("a");
57         myQueue.put("b");
58         myQueue.put("c");
59         myQueue.put("d");
60         myQueue.put("e");
61         System.out.println("當前對列的長度：" + myQueue.list.size());
62 
63         Thread t1 = new Thread(new Runnable() {
64 
65             @Override
66             public void run() {
67                 myQueue.put("f");
68                 myQueue.put("g");
69             }
70         }, "t1");
71         t1.start();
72         Thread t2 = new Thread(new Runnable() {
73 
74             @Override
75             public void run() {
76                 Object o1 = myQueue.take();
77                 System.out.println("移除的元素爲：" + o1);
78                 Object o2 = myQueue.take();
79                 System.out.println("移除的元素爲：" + o2);
80             }
81         }, "t2");
82         try {
83             TimeUnit.SECONDS.sleep(2);
84         } catch (InterruptedException e) {
85             // TODO Auto-generated catch block
86             e.printStackTrace();
87         }
88         t2.start();
89 
90     }
91 }