看了张孝祥老师的多线程，今天终于搞清楚Lock和Condition定义的缓冲区的问题了，分享一下思路，这个可以理解为单个生产者单个消费者或者多个生产者多个消费者在100个货架上按顺序依次生产消费的过程：

1.                 class BoundedBuffer {
   
2. //                                定义一个锁，保证在屋里生产或者消费的只有一个人。如果想多个人可以同时进入房间，得定义多把锁
   
3.                            final Lock lock = new ReentrantLock();
   
4.                            final Condition notFull  = lock.newCondition();
   
5.                            final Condition notEmpty = lock.newCondition();
   
6. //                                定义100个货架
   
7.                            final Object[] items = new Object[100];
   
8.                            int putptr, takeptr, count;
   
9. 
   
10.                            public void put(Object x) throws InterruptedException {
    
11.                              lock.lock();
    
12.                              try {
    
13.                                while (count == items.length)
    
14. //                                     4、如果下一个生产者进来时蛋糕数已达100就等待
    
15.                                  notFull.await();
    
16. //                               1、生产者进来把生产的蛋糕放入第putptr
    
17.                                items[putptr] = x;
    
18. //                               2、下次生产完放在第putptr+1个货架，如果放到第99个后，putptr改为0，从头放
    
19.                                if (++putptr == items.length) putptr = 0;
    
20. //                               3、放完一个，蛋糕数+1，叫醒消费者并放锁
    
21.                                ++count;
    
22.                                notEmpty.signal();
    
23.                              } finally {
    
24.                                lock.unlock();
    
25.                              }
    
26.                            }
    
27. 
    
28.                            public Object take() throws InterruptedException {
    
29.                              lock.lock();
    
30.                              try {
    
31. //                                    
    
32.                                while (count == 0)
    
33. //                                     8、如果下一个消费者进来时蛋糕数为0就等待
    
34.                                  notEmpty.await();
    
35. //                               5、消费者进来，取第takeptr个蛋糕
    
36.                                Object x = items[takeptr];
    
37. //                               6、下次消费去取第takeptr+1个蛋糕，如果取到第99个后，takeptr改为0，从头取
    
38.                                if (++takeptr == items.length) takeptr = 0;
    
39. //                               7、取完一个，蛋糕数-1，叫醒生产者并放锁
    
40.                                --count;
    
41.                                notFull.signal();
    
42.                                return x;
    
43.                              } finally {
    
44.                                lock.unlock();
    
45.                              }
    
46.                            }
    
47.                          }
    

复制代码

看了张孝祥老师的多线程，今天终于搞清楚Lock和Condition定义的缓冲区的问题了，分享一下思路，这个可以理解为单个生产者单个消费者或者多个生产者多个消费者在100个货架上按顺序依次生产消费的过程：

1.                 class BoundedBuffer {
   
2. //                                定义一个锁，保证在屋里生产或者消费的只有一个人。如果想多个人可以同时进入房间，得定义多把锁
   
3.                            final Lock lock = new ReentrantLock();
   
4.                            final Condition notFull  = lock.newCondition();
   
5.                            final Condition notEmpty = lock.newCondition();
   
6. //                                定义100个货架
   
7.                            final Object[] items = new Object[100];
   
8.                            int putptr, takeptr, count;
   
9. 
   
10.                            public void put(Object x) throws InterruptedException {
    
11.                              lock.lock();
    
12.                              try {
    
13.                                while (count == items.length)
    
14. //                                     4、如果下一个生产者进来时蛋糕数已达100就等待
    
15.                                  notFull.await();
    
16. //                               1、生产者进来把生产的蛋糕放入第putptr
    
17.                                items[putptr] = x;
    
18. //                               2、下次生产完放在第putptr+1个货架，如果放到第99个后，putptr改为0，从头放
    
19.                                if (++putptr == items.length) putptr = 0;
    
20. //                               3、放完一个，蛋糕数+1，叫醒消费者并放锁
    
21.                                ++count;
    
22.                                notEmpty.signal();
    
23.                              } finally {
    
24.                                lock.unlock();
    
25.                              }
    
26.                            }
    
27. 
    
28.                            public Object take() throws InterruptedException {
    
29.                              lock.lock();
    
30.                              try {
    
31. //                                    
    
32.                                while (count == 0)
    
33. //                                     8、如果下一个消费者进来时蛋糕数为0就等待
    
34.                                  notEmpty.await();
    
35. //                               5、消费者进来，取第takeptr个蛋糕
    
36.                                Object x = items[takeptr];
    
37. //                               6、下次消费去取第takeptr+1个蛋糕，如果取到第99个后，takeptr改为0，从头取
    
38.                                if (++takeptr == items.length) takeptr = 0;
    
39. //                               7、取完一个，蛋糕数-1，叫醒生产者并放锁
    
40.                                --count;
    
41.                                notFull.signal();
    
42.                                return x;
    
43.                              } finally {
    
44.                                lock.unlock();
    
45.                              }
    
46.                            }
    
47.                          }
    

复制代码