原文地址:http://eric-619.iteye.com/blog/693681

 

Java代码  

1. /*@src  http://eric-619.iteye.com/blog/693681  
2. * 生产者消费者问题其含义就是先生产出了产品，才能拉出去让消费者购买  
3. * 一、重点：  
4. *    1、多个线程数据共享区域化思想！---源于多线程的近亲思想！！（类似于静态变量的改变）  
5. *    （如栈内存和对内存，还有当做栈内存和堆内存，如数组和基本数据类型，只要是访问的同一个。）  
6. *    2、生产者消费者  
7. *      
8. * 二、synchronized加锁:  
9. *   
10. */  
11.   
12.   
13. public class ProCon{ //主方法   
14.   
15. public static void main(String[] args){   
16. SyncStack stack = new SyncStack();   
17. Consumer p = new Consumer(stack);   
18. Producer c = new Producer(stack);   
19.   
20.   
21. new Thread(p).start();   
22. new Thread(c).start();   
23. }   
24. }   
25.   
26. class Producer implements Runnable{   //生产者   
27.     private SyncStack stack;   
28.   
29.     public Producer(SyncStack stack){   
30.     this.stack = stack;   
31.      }   
32.   
33.     public void run(){   
34.     for (int i = 0; i < stack.pro().length; i++){   
35.     String product = "产品"+i;   
36.     stack.push(product);   
37.     System.out.println("生产了: "+product);   
38.     try{   
39.      Thread.sleep(200);   
40.      }catch(InterruptedException e)   
41.       {   
42.        e.printStackTrace();   
43.      }   
44.    }   
45. }   
46. }   
47.   
48. class Consumer implements Runnable{   //消费者   
49.    private SyncStack stack;   
50.   
51.    public Consumer(SyncStack stack) {   
52.    this.stack = stack;   
53.     }   
54.       
55.    public void run(){   
56.    for(int i = 0; i < stack.pro().length; i++){   
57.     String product = stack.pop();   
58.     System.out.println("消费了: "+product);   
59.     try{   
60.      Thread.sleep(1000);   
61.    }catch(InterruptedException e){   
62.      e.printStackTrace();   
63.      }   
64.     }   
65.    }   
66. }   
67.   
68. class SyncStack{   // 此类是（本质上：共同访问的）共享数据区域   
69. private String[] str = new String[10];   
70.     private int index;   
71.        
72.     public synchronized void push(String sst){ //供生产者调用   
73.     if(index == sst.length()){   
74.      try{   
75.       wait();   
76.      }catch(InterruptedException e){   
77.        e.printStackTrace();   
78.       }   
79.     }   
80.    this.notify(); //唤醒在此对象监视器上等待的单个线程   
81.    str[index] = sst;   
82.    index++;   
83. }   
84.   
85.    public synchronized String pop(){   //供消费者调用   
86.     if(index == 0){   
87.      try{   
88.       wait();   
89.       }catch (InterruptedException e){   
90.        e.printStackTrace();   
91.       }   
92.    }   
93.     notify();   
94.     index--;   
95.     String product = str[index];   
96.     return product;   
97.    }   
98.   
99.     public String[] pro(){ //就是定义一个返回值为数组的方法,返回的是一个String[]引用   
100.      return str;   //这是一个String[]引用   
101.    }   
102. }  

/*@src  http://eric-619.iteye.com/blog/693681
* 生产者消费者问题其含义就是先生产出了产品，才能拉出去让消费者购买
* 一、重点：
*    1、多个线程数据共享区域化思想！---源于多线程的近亲思想！！（类似于静态变量的改变）
*    （如栈内存和对内存，还有当做栈内存和堆内存，如数组和基本数据类型，只要是访问的同一个。）
*    2、生产者消费者
*    
* 二、synchronized加锁:
* 
*/


public class ProCon{ //主方法

public static void main(String[] args){
SyncStack stack = new SyncStack();
Consumer p = new Consumer(stack);
Producer c = new Producer(stack);


new Thread(p).start();
new Thread(c).start();
}
}

class Producer implements Runnable{   //生产者
    private SyncStack stack;

    public Producer(SyncStack stack){
    this.stack = stack;
     }

    public void run(){
    for (int i = 0; i < stack.pro().length; i++){
    String product = "产品"+i;
    stack.push(product);
    System.out.println("生产了: "+product);
    try{
     Thread.sleep(200);
     }catch(InterruptedException e)
      {
       e.printStackTrace();
     }
   }
}
}

class Consumer implements Runnable{   //消费者
   private SyncStack stack;

   public Consumer(SyncStack stack) {
   this.stack = stack;
    }
   
   public void run(){
   for(int i = 0; i < stack.pro().length; i++){
    String product = stack.pop();
    System.out.println("消费了: "+product);
    try{
     Thread.sleep(1000);
   }catch(InterruptedException e){
     e.printStackTrace();
     }
    }
   }
}

class SyncStack{   // 此类是（本质上：共同访问的）共享数据区域
private String[] str = new String[10];
    private int index;
    
    public synchronized void push(String sst){ //供生产者调用
    if(index == sst.length()){
     try{
      wait();
     }catch(InterruptedException e){
       e.printStackTrace();
      }
    }
   this.notify(); //唤醒在此对象监视器上等待的单个线程
   str[index] = sst;
   index++;
}

   public synchronized String pop(){   //供消费者调用
    if(index == 0){
     try{
      wait();
      }catch (InterruptedException e){
       e.printStackTrace();
      }
   }
    notify();
    index--;
    String product = str[index];
    return product;
   }

    public String[] pro(){ //就是定义一个返回值为数组的方法,返回的是一个String[]引用
     return str;   //这是一个String[]引用
   }
}

分享到：