Java多线程简单样例（二）：使用lock锁的生产者消费者问题

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 生产者消费者模式
 * @author fliay
 *
 */
public class TestProductorAndConsumerByLock {

    public static void main(String[] args) {
        ClerkByLock c = new ClerkByLock();
        ProductorByLock pro = new ProductorByLock(c);
        ConsumerByLock con = new ConsumerByLock(c);
        new Thread(pro,"生产者A").start();
        new Thread(con,"消费者B").start();
        new Thread(pro,"生产者C").start();
        new Thread(con,"消费者D").start();
    }
    
    
    

}

class  ClerkByLock{
    //初始化产品
    private int product = 0;
    //定义一个Lock锁对象
    private Lock lock = new ReentrantLock();
    //创建condition对象
    private Condition condition = lock.newCondition();
    
    
    //进货
    public  void get(){
        lock.lock();
        
        try{
            while(product>=10){
                System.out.println("产品已满！");
                try {
                    //使用condition进行线程等待
                    condition.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            condition.signalAll();
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
        }finally{
            //始终会解锁
            lock.unlock();
        }
        
        
        
        
    }
    
    //卖货
    public  void sale(){
        lock.lock();
        try{
            
            while(product<=0){
                System.out.println("补货中！");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            condition.signalAll();
            System.out.println(Thread.currentThread().getName()+":"+ --product);
        }finally{
            lock.unlock();
        }
        
        
    }
}

class ProductorByLock implements Runnable{
    
    private ClerkByLock clerk;
    
    
    public ProductorByLock(ClerkByLock clerk) {
        this.clerk = clerk;
    }



    public void run() {
        for(int i=0;i<20;i++){
            clerk.get();
        }
    }
}


class ConsumerByLock implements Runnable{
    
    private ClerkByLock clerk;
    
    
    
    public ConsumerByLock(ClerkByLock clerk) {
        this.clerk = clerk;
    }



    public void run() {
        for(int i=0;i<20;i++){
            clerk.sale();
        }
    }
}

运行结果如下：

生产者A:1
消费者B:0
补货中！
生产者C:1
生产者C:2
生产者C:3
生产者C:4
生产者C:5
生产者C:6
生产者C:7
生产者C:8
生产者C:9
消费者D:8
消费者D:7
消费者D:6
消费者D:5
消费者D:4
消费者D:3
消费者D:2
消费者D:1
消费者D:0
补货中！
生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
生产者A:10
产品已满！
消费者B:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0
补货中！
生产者C:1
生产者C:2
生产者C:3
生产者C:4
生产者C:5
生产者C:6
生产者C:7
生产者C:8
生产者C:9
生产者C:10
产品已满！
消费者D:9
消费者D:8
消费者D:7
消费者D:6
消费者D:5
消费者D:4
消费者D:3
消费者D:2
消费者D:1
消费者D:0
补货中！
生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0
生产者C:1
消费者D:0