其实应该说是 模拟 多线程对一个数组同时进行读取的功能（缓冲区）
变量 count 表示缓冲区剩余数据的个数 为0时则要求读进程等待，等于数组长度时，则要求写进程等待
这样能避免对同一个数据重复取，或者覆盖写

1. package demo;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. public class ProducerAndConsumerByBuffer {
   
8. 
   
9.         /**
   
10.          * 利用数组解决生产消费问题
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 final Buff b = new Buff();
    
14.                 new Thread(){
    
15.                         public void run() {
    
16.                                 while(true)
    
17.                                         b.pro();
    
18.                         };
    
19.                 }.start();
    
20.                 new Thread(){
    
21.                         public void run() {
    
22.                                 while(true)
    
23.                                         b.con();
    
24.                         };
    
25.                 }.start();
    
26.                 new Thread(){
    
27.                         public void run() {
    
28.                                 while(true)
    
29.                                         b.pro();
    
30.                         };
    
31.                 }.start();
    
32.         }
    
33. 
    
34. }
    
35. class Buff{
    
36.         private int[] buf = new int[5];
    
37.         private int proPos = 0,conPos=0;//数组指针
    
38.         private int count = 0;//指示剩余数量
    
39.         Lock lock = new ReentrantLock();
    
40.         Condition notFull = lock.newCondition();
    
41.         Condition notEmpty = lock.newCondition();
    
42.         public void pro(){
    
43.                 lock.lock();
    
44.                 try{
    
45.                         while(count==buf.length){ //缓冲区已满  待取走
    
46.                                 try {
    
47.                                         notEmpty.await();
    
48.                                 } catch (InterruptedException e) {
    
49.                                         e.printStackTrace();
    
50.                                 }
    
51.                         }
    
52.                         try {
    
53.                                 Thread.sleep(500);
    
54.                         } catch (InterruptedException e) {
    
55.                                 // TODO Auto-generated catch block
    
56.                                 e.printStackTrace();
    
57.                         }
    
58.                         buf[proPos] = 1;
    
59.                         System.out.println(Thread.currentThread().getName()+"...生产"+proPos);
    
60.                         if((++proPos)==buf.length)
    
61.                                 proPos = 0;
    
62.                         count++;
    
63.                         notFull.signal();
    
64.                 }finally{
    
65.                         lock.unlock();
    
66.                 }
    
67.         }
    
68.         public void con(){
    
69.                 lock.lock();
    
70.                 try{
    
71.                         while(count==0){ //缓冲区已空  待新数据
    
72.                                 try {
    
73.                                         notFull.await();
    
74.                                 } catch (InterruptedException e) {
    
75.                                         e.printStackTrace();
    
76.                                 }
    
77.                         }
    
78.                         try {
    
79.                                 Thread.sleep(500);
    
80.                         } catch (InterruptedException e) {
    
81.                                 // TODO Auto-generated catch block
    
82.                                 e.printStackTrace();
    
83.                         }
    
84.                         buf[conPos] = 0;
    
85.                         System.out.println(Thread.currentThread().getName()+"...消费"+conPos);
    
86.                         if(++conPos == buf.length)
    
87.                                 conPos = 0;
    
88.                         count--;
    
89.                         notEmpty.signal();
    
90.                 }finally{
    
91.                         lock.unlock();
    
92.                 }
    
93.         }
    
94. }

复制代码

其实应该说是 模拟 多线程对一个数组同时进行读取的功能（缓冲区）
变量 count 表示缓冲区剩余数据的个数 为0时则要求读进程等待，等于数组长度时，则要求写进程等待
这样能避免对同一个数据重复取，或者覆盖写

1. package demo;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. public class ProducerAndConsumerByBuffer {
   
8. 
   
9.         /**
   
10.          * 利用数组解决生产消费问题
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 final Buff b = new Buff();
    
14.                 new Thread(){
    
15.                         public void run() {
    
16.                                 while(true)
    
17.                                         b.pro();
    
18.                         };
    
19.                 }.start();
    
20.                 new Thread(){
    
21.                         public void run() {
    
22.                                 while(true)
    
23.                                         b.con();
    
24.                         };
    
25.                 }.start();
    
26.                 new Thread(){
    
27.                         public void run() {
    
28.                                 while(true)
    
29.                                         b.pro();
    
30.                         };
    
31.                 }.start();
    
32.         }
    
33. 
    
34. }
    
35. class Buff{
    
36.         private int[] buf = new int[5];
    
37.         private int proPos = 0,conPos=0;//数组指针
    
38.         private int count = 0;//指示剩余数量
    
39.         Lock lock = new ReentrantLock();
    
40.         Condition notFull = lock.newCondition();
    
41.         Condition notEmpty = lock.newCondition();
    
42.         public void pro(){
    
43.                 lock.lock();
    
44.                 try{
    
45.                         while(count==buf.length){ //缓冲区已满  待取走
    
46.                                 try {
    
47.                                         notEmpty.await();
    
48.                                 } catch (InterruptedException e) {
    
49.                                         e.printStackTrace();
    
50.                                 }
    
51.                         }
    
52.                         try {
    
53.                                 Thread.sleep(500);
    
54.                         } catch (InterruptedException e) {
    
55.                                 // TODO Auto-generated catch block
    
56.                                 e.printStackTrace();
    
57.                         }
    
58.                         buf[proPos] = 1;
    
59.                         System.out.println(Thread.currentThread().getName()+"...生产"+proPos);
    
60.                         if((++proPos)==buf.length)
    
61.                                 proPos = 0;
    
62.                         count++;
    
63.                         notFull.signal();
    
64.                 }finally{
    
65.                         lock.unlock();
    
66.                 }
    
67.         }
    
68.         public void con(){
    
69.                 lock.lock();
    
70.                 try{
    
71.                         while(count==0){ //缓冲区已空  待新数据
    
72.                                 try {
    
73.                                         notFull.await();
    
74.                                 } catch (InterruptedException e) {
    
75.                                         e.printStackTrace();
    
76.                                 }
    
77.                         }
    
78.                         try {
    
79.                                 Thread.sleep(500);
    
80.                         } catch (InterruptedException e) {
    
81.                                 // TODO Auto-generated catch block
    
82.                                 e.printStackTrace();
    
83.                         }
    
84.                         buf[conPos] = 0;
    
85.                         System.out.println(Thread.currentThread().getName()+"...消费"+conPos);
    
86.                         if(++conPos == buf.length)
    
87.                                 conPos = 0;
    
88.                         count--;
    
89.                         notEmpty.signal();
    
90.                 }finally{
    
91.                         lock.unlock();
    
92.                 }
    
93.         }
    
94. }

复制代码