Java语言synchronized与lock实现生产者消费者

synchronized方式

package test;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

public class ProducerConsumer {

    public static void main(String args[]) { 
        Queue<Integer> buffer = new LinkedList<>(); 
        int maxSize = 10; 
        ProducerConsumer producerConsumer = new ProducerConsumer();
        Thread producer = producerConsumer.new Producer(buffer, maxSize, "PRODUCER"); 
        Thread consumer = producerConsumer.new Consumer(buffer, maxSize, "CONSUMER"); 
        producer.start(); 
        consumer.start();  
    } 

    class Producer extends Thread{
        private Queue<Integer> queue;
        private int maxSize;
        public Producer(Queue<Integer> queue,int maxSize,String name) {
            super(name);
            this.queue = queue;
            this.maxSize = maxSize;
        }
        @Override
        public void run() {
            while(true) {
                synchronized (queue) {
                    while(queue.size() == maxSize) {
                        System.out.println("Queue is full");
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Random random = new Random();
                    int i = random.nextInt();
                    System.out.println("Producing value : " + i); 
                    queue.add(i); 
                    queue.notifyAll();
                }
            }
        }


    }

    class Consumer extends Thread{
        private Queue<Integer> queue; 
        private int maxSize; 
        public Consumer(Queue<Integer> queue, int maxSize, String name){ 
            super(name); 
            this.queue = queue; 
            this.maxSize = maxSize; 
        } 
        @Override 
        public void run() { 
            while (true) { 
                synchronized (queue) { 
                    while (queue.isEmpty()) { 
                        System.out.println("Queue is empty"); 
                        try { 
                            queue.wait(); 
                        } catch (Exception ex) { 
                            ex.printStackTrace(); 
                        } 
                    } 
                    System.out.println("Consuming value : " + queue.remove()); 
                    queue.notifyAll(); 
                } 
            } 
        } 
    }
}

lock方式

package test;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockProducerConsumer {
    Lock lock = new ReentrantLock();
    Condition conditionP = lock.newCondition();
    Condition conditionC = lock.newCondition();
    public static void main(String args[]) { 
        Queue<Integer> buffer = new LinkedList<>(); 
        int maxSize = 10; 
        LockProducerConsumer producerConsumer = new LockProducerConsumer();
        Thread producer = producerConsumer.new Producer(buffer, maxSize, "PRODUCER"); 
        Thread consumer = producerConsumer.new Consumer(buffer, "CONSUMER"); 
        producer.start(); 
        consumer.start();  
    } 

    class Producer extends Thread{
        private Queue<Integer> queue;
        private int maxSize;
        public Producer(Queue<Integer> queue,int maxSize,String name) {
            super(name);
            this.queue = queue;
            this.maxSize = maxSize;
        }
        @Override
        public void run() {
            while(true) {
                lock.lock();
                try {
                    while (true) { 

                        while (queue.size() == maxSize) { 
                            System.out.println("Queue is full");
                            try {
                                conditionP.await();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        } 
                        Random random = new Random();
                        int i = random.nextInt();
                        System.out.println("Producing value : " + i); 
                        queue.add(i);
                        conditionC.signal();


                    }
                }finally {
                    lock.unlock();
                }

            }
        }


    }

    class Consumer extends Thread{
        private Queue<Integer> queue; 
        public Consumer(Queue<Integer> queue, String name){ 
            super(name); 
            this.queue = queue;
        } 
        @Override 
        public void run() { 
            lock.lock();
            try {
                while (true) { 

                    while (queue.isEmpty()) { 
                        System.out.println("Queue is empty"); 
                        try {
                            conditionC.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } 
                    System.out.println("Consuming value : " + queue.remove()); 
                    conditionP.signal();

                } 
            }finally {
                lock.unlock();
            }

        } 
    }
}