这是个线程同步的经典例子,源代码如下:

 

[java]   view plain copy
    1. <span style="font-size:16px;">package demo.thread;  
    2.   
    3. /** 
    4.  *经典生产者与消费者问题:生产者不断的往仓库中存放产品,消费者从仓库中消费产品。 
    5.  *其中生产者和消费者都可以有若干个。仓库容量有限,库满时不能存放,库空时不能取产品  
    6.  */  
    7.   
    8. public class ProducersAndConsumers {  
    9.     public static void main(String[] args) {  
    10.         Storage storage = new Storage();  
    11.         Thread consumer = new Thread(new Consumer(storage));  
    12.         consumer.setName("消费者");  
    13.         Thread producer = new Thread(new Producer(storage));  
    14.         producer.setName("生产者");  
    15.         consumer.start();  
    16.         producer.start();  
    17.     }  
    18. }  
    19.   
    20. /** 
    21.  * 消费者 
    22.  */  
    23. class Consumer implements Runnable {  
    24.     private Storage storage;  
    25.   
    26.     public Consumer(Storage storage) {  
    27.         this.storage = storage;  
    28.     }  
    29.   
    30.     @Override  
    31.     public void run() {  
    32.         storage.pop();  
    33.     }  
    34. }  
    35.   
    36. /** 
    37.  * 生产者 
    38.  */  
    39. class Producer implements Runnable {  
    40.     private Storage storage;  
    41.   
    42.     public Producer(Storage storage) {  
    43.         this.storage = storage;  
    44.     }  
    45.   
    46.     @Override  
    47.     public void run() {  
    48.         Product product = new Product("090505105""电话");  
    49.         storage.push(product);  
    50.     }  
    51.   
    52. }  
    53.   
    54. /** 
    55.  * 产品类 
    56.  */  
    57. class Product {  
    58.     private String id;// 产品id  
    59.     private String name;// 产品名称  
    60.   
    61.     public Product(String id, String name) {  
    62.         this.id = id;  
    63.         this.name = name;  
    64.     }  
    65.   
    66.     @Override  
    67.     public String toString() {  
    68.         return "(产品ID:" + id + " 产品名称:" + name + ")";  
    69.     }  
    70.   
    71.     public String getId() {  
    72.         return id;  
    73.     }  
    74.   
    75.     public void setId(String id) {  
    76.         this.id = id;  
    77.     }  
    78.   
    79.     public String getName() {  
    80.         return name;  
    81.     }  
    82.   
    83.     public void setName(String name) {  
    84.         this.name = name;  
    85.     }  
    86.   
    87. }  
    88.   
    89. /** 
    90.  *仓库 
    91.  */  
    92. class Storage {  
    93.     // 仓库容量为10  
    94.     private Product[] products = new Product[10];  
    95.     private int top = 0;  
    96.   
    97.     // 生产者往仓库中放入产品  
    98.     public synchronized void push(Product product) {  
    99.         while (top == products.length) {  
    100.             try {  
    101.                 wait();//仓库已满,等待  
    102.             } catch (InterruptedException e) {  
    103.                 // TODO Auto-generated catch block  
    104.                 e.printStackTrace();  
    105.             }  
    106.         }  
    107.         //把产品放入仓库  
    108.         products[top++] = product;  
    109.         System.out.println(Thread.currentThread().getName() + " 生产了产品"  
    110.                 + product);  
    111.         notifyAll();//唤醒等待线程  
    112.   
    113.     }  
    114.   
    115.     // 消费者从仓库中取出产品  
    116.     public synchronized Product pop() {  
    117.         while (top == 0) {  
    118.             try {  
    119.                 wait();//仓库空,等待  
    120.             } catch (InterruptedException e) {  
    121.                 // TODO Auto-generated catch block  
    122.                 e.printStackTrace();  
    123.             }  
    124.   
    125.         }  
    126.   
    127.         //从仓库中取产品  
    128.         --top;  
    129.         Product p = new Product(products[top].getId(), products[top].getName());  
    130.         products[top] = null;  
    131.         System.out.println(Thread.currentThread().getName() + " 消费了产品" + p);  
    132.         notifyAll();//唤醒等待线程  
    133.         return p;  
    134.     }  
    135. }  
    136. </span>

转载于:https://www.cnblogs.com/kinghitomi/archive/2012/01/19/2327420.html

Logo

开放原子开发者工作坊旨在鼓励更多人参与开源活动,与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动,如meetup、训练营等,主打技术交流,干货满满,真诚地邀请各位开发者共同参与!

更多推荐