使用锁模拟写一个固定容量同步容器(马士兵并发笔记)

写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持多个生产者和多个消费者线程拥塞调用。

1.使用synchronized锁或ReentrantLock锁实现

1）使用synchronized锁的notify、notifyAll来实现

基本思路：使用put方法向容器中添加元素，使用get方法从容器中取出元素，在使用put方法添加元素的时候进行判断，如果容器已经满了，此时调用wait()方法，使用添加线程阻塞，等待消费线程取出元素，腾出容器空间后才能再向其中添加元素，同理当使用get方法获取元素的时候，如果同期已经为空，此时要调用wait()方法，使得取出线程阻塞，等待添加线程添加元素，容器有值后才能再从容器中取出元素。

  1. public class MyContainer1<T> {
  2. 	final private LinkedList<T> lists = new LinkedList<>();
  3. 	final private int MAX = 10; //最多10个元素
  4. 	private int count = 0;
  5. 	
  6. 	
  7. 	public synchronized void put(T t) {
  8. 		while(lists.size() == MAX) { //想想为什么用while而不是用if？
  9. 			try {
  10. 				this.wait(); //effective java
  11. 			} catch (InterruptedException e) {
  12. 				e.printStackTrace();
  13. 			}
  14. 		}
  15. 		lists.add(t);
  16. 		++count;
  17. 		System.out.println("生产者容器中的物品数: "+count);
  18. 		this.notifyAll(); //通知消费者线程进行消费
  19. 	}
  20. 	
  21. 	public synchronized T get() {
  22. 		T t = null;
  23. 		while(lists.size() == 0) {
  24. 			try {
  25. 				this.wait();
  26. 			} catch (InterruptedException e) {
  27. 				e.printStackTrace();
  28. 			}
  29. 		}
  30. 		t = lists.removeFirst();
  31. 		count --;
  32. 		System.out.println("消费者容器中的物品数: "+count);
  33. 		this.notifyAll(); //通知生产者进行生产
  34. 		return t;
  35. 	}
  36. 	
  37. 	public static void main(String[] args) {
  38. 		MyContainer1<String> c = new MyContainer1<>();
  39. 		//启动消费者线程
  40. 		for(int i=0; i<10; i++) {
  41. 			new Thread(()->{
  42. 				for(int j=0; j<5; j++) 	//生产者执行了50次
  43. 					c.get();
  44. 					//System.out.println(c.get());
  45. 			}, "c" + i).start();
  46. 		}
  47. 		
  48. 		try {
  49. 			TimeUnit.SECONDS.sleep(2);
  50. 		} catch (InterruptedException e) {
  51. 			e.printStackTrace();
  52. 		}
  53. 		
  54. 		//启动生产者线程
  55. 		for(int i=0; i<2; i++) {
  56. 			new Thread(()->{
  57. 				for(int j=0; j<25; j++) 	//消费者执行了50次
  58. 					c.put(Thread.currentThread().getName() + " " + j);
  59. 			}, "p" + i).start();
  60. 		}
  61. 	}
  62. }
public static void main(String[] args) {MyContainer1<String> c = new MyContainer1<>();//启动消费者线程for(int i=0; i<10; i++) {new Thread(()->{for(int j=0; j<5; j++) //生产者执行了50次c.get();//System.out.println(c.get());}, "c" + i).start();}try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}//启动生产者线程for(int i=0; i<2; i++) {new Thread(()->{for(int j=0; j<25; j++) //消费者执行了50次c.put(Thread.currentThread().getName() + " " + j);}, "p" + i).start();}}}

说明：如下的代码中应当注意三点：

        第一点：在count--后，this.notifyAll()的作用是处理这样一种情况：如果容器满了，此时生产者线程被阻塞，这是消费者线程消费了元素后，注意要唤醒生产者线程，如果没有这一步，那么只有消费者线程执行，消费者线程都执行完或者执行到容量为空时，此时会出现生成者线程一直被阻塞等待锁的情况，此时程序将停留在这里。

        第二点：注意这里的while(lists.size()==0)不能换成if(lists.size())==0，分析：考虑这样一种情况，容器为空，消费线程t1和t2调用wait()方法进入阻塞，此时生产线程t3生产了一个元素后，唤醒所有的线程后，此时线程t1从this.wait()后面直接执行，消费一个元素后，线程t2从this.wait()后的代码直接执行，并不会判断，此时容器已经为空，但它依旧取出一个元素，导致了报错。

        第三点：this.notifyAll()不能换成this.notify()，因为如果换成this.notify()函数，此时只唤醒一个线程，假设这样一种状态，消费者线程消费了最后一个元素后，容器为空，此时消费者线程本打算唤醒生产者线程，结果却唤醒了消费者线程，消费者线程在执行了while(lists.size()==0)中的this.wait()方法后进入阻塞状态，此时被唤醒的消费者线程也进入阻塞状态，程序死锁。

2）使用ReentrantLock锁的notify、notifyAll来实现

  1. public class MyContainer2<T> {
  2. 	final private LinkedList<T> lists = new LinkedList<>();
  3. 	final private int MAX = 10; //最多10个元素
  4. 	private int count = 0;
  5. 	
  6. 	private Lock lock = new ReentrantLock();
  7. 	private Condition producer = lock.newCondition();
  8. 	private Condition consumer = lock.newCondition();
  9. 	
  10. 	public void put(T t) {
  11. 		try {
  12. 			lock.lock();
  13. 			while(lists.size() == MAX) { //想想为什么用while而不是用if？
  14. 				producer.await();		//当消费者线程们执行到这里的时候等待
  15. 			}
  16. 			
  17. 			lists.add(t);
  18. 			++count;
  19. 			System.out.println("里面有个数："+count);
  20. 			consumer.signalAll(); //通知消费者线程进行消费
  21. 		} catch (InterruptedException e) {
  22. 			e.printStackTrace();
  23. 		} finally {
  24. 			lock.unlock();
  25. 		}
  26. 	}
  27. 	
  28. 	public T get() {
  29. 		T t = null;
  30. 		try {
  31. 			lock.lock();
  32. 			while(lists.size() == 0) {
  33. 				consumer.await();	//当生产者线程执行到这里的等待
  34. 			}
  35. 			t = lists.removeFirst();
  36. 			count --;
  37. 			System.out.println("里面有个数："+count);
  38. 			producer.signalAll(); //通知生产者的线程们进行生产
  39. 		} catch (InterruptedException e) {
  40. 			e.printStackTrace();
  41. 		} finally {
  42. 			lock.unlock();
  43. 		}
  44. 		return t;
  45. 	}
  46. 	
  47. 	public static void main(String[] args) {
  48. 		MyContainer2<String> c = new MyContainer2<>();
  49. 		//启动消费者线程
  50. 		for(int i=0; i<10; i++) {
  51. 			new Thread(()->{
  52. 				for(int j=0; j<5; j++) 
  53. 					c.get();
  54. 					//System.out.println(c.get());
  55. 			}, "c" + i).start();
  56. 		}
  57. 		
  58. 		try {
  59. 			TimeUnit.SECONDS.sleep(2);
  60. 		} catch (InterruptedException e) {
  61. 			e.printStackTrace();
  62. 		}
  63. 		
  64. 		//启动生产者线程
  65. 		for(int i=0; i<2; i++) {
  66. 			new Thread(()->{
  67. 				for(int j=0; j<25; j++) 
  68. 					c.put(Thread.currentThread().getName() + " " + j);
  69. 			}, "p" + i).start();
  70. 		}
  71. 	}
  72. }

说明：ReentrantLock锁的好处，可以创建多个Condition队列，如上面的代码，创建了consumer和producer队列，在get方法中会将执行该方法的消费者线程通过consumer.await()方法阻塞consumer队列中，同时在get方法中可以只唤醒consumer(生产者)队列的线程。

2.直接使用BlockingQueue实现

1）BlockingQueue是一个接口，并非具体实现，常见的BlockingQueue实现有ArrayBlockingQueue和LinkedBlockingQueue。ArrayBlockingQueue是基于数组实现，而LinkedBlockingQueue是基于链表实现。

2）向队列中压入元素课可以使用offer()方法和put()方法，对于offer()方法，如果队列已经满了，它就会立即返回false，如果没有满，则执行正常的入队列操作，而put()方法，如果队列满了，它会一直等待，直到队列中有空闲的位置。

3）从队列中弹出元素，可以使用poll()方法和take()方法，如果队列为空poll()方法直接返回null，而take()方法会一直等待，直到队列内有可用元素。

4）put()方法和take()方法体现Blocking的关键。

使用LinkedBlockingQueue实现上面的固定同步容器代码如下：

  1. public class TestBlockingQueue<T> {  
  2.     //final private LinkedList<T> lists = new LinkedList<>();
  3. 	BlockingQueue<T> queue = new LinkedBlockingDeque<>(10);
  4. 	     
  5.     //生产者线程
  6.     public void put(T t) {  
  7.         try {  
  8.             queue.put(t);  
  9.             System.out.println("里面有个数："+queue.size());  
  10.         } catch (InterruptedException e) {  
  11.             e.printStackTrace();  
  12.         }  
  13.     }  
  14.       
  15.     public T get() {  
  16.         T t = null;  
  17.             try {
  18. 				queue.take();
  19. 				System.out.println("里面有个数："+queue.size());  
  20. 			} catch (InterruptedException e) {
  21. 				e.printStackTrace();
  22. 			}
  23.             
  24.         return t;  
  25.     }  
  26.       
  27.     public static void main(String[] args) {  
  28.         TestBlockingQueue<String> c = new TestBlockingQueue<>();  
  29.         //启动消费者线程  
  30.         for(int i=0; i<10; i++) {  
  31.             new Thread(()->{  
  32.                 for(int j=0; j<5; j++)   
  33.                     c.get();  
  34.                     //System.out.println(c.get());  
  35.             }, "c" + i).start();  
  36.         }  
  37.           
  38.         try {  
  39.             TimeUnit.SECONDS.sleep(2);  
  40.         } catch (InterruptedException e) {  
  41.             e.printStackTrace();  
  42.         }  
  43.           
  44.         //启动生产者线程  
  45.         for(int i=0; i<2; i++) {  
  46.             new Thread(()->{  
  47.                 for(int j=0; j<25; j++)   
  48.                     c.put(Thread.currentThread().getName() + " " + j);  
  49.             }, "p" + i).start();  
  50.         }  
  51.     }  
  52. }

posted @ 2018-06-26 15:57  星朝  阅读(679)  评论(0)  编辑  收藏  举报