Lock锁机制和synchronize分别实现生产者消费者例程

存在问题

像前面实现消费者生产者例程那样，地址，直接操作线程这种方式是可以的，但对于并发编程，这样的代码很快变得容易出错，特别是好几个线程需要协作来完成一个更大的任务的时候。这种情况下，它们的控制流需要被协调。

例如，一个线程的执行完成可能依赖于其他将要执行完成的线程。通常熟悉的例子就是生产者/消费者的例子，因为如果消费者队列是空的，那么生产者应该等待消费者，并且如果生产者队列是空的，那么消费者也应该等待生产者。该需求可能通过共享状态和条件队列来实现，但是你仍然必须通过使用共享对象上的java.lang.Object.nofity()和java.lang.Object.wait()来实现同步，这很容易出错。

最终，一个常见的错误就是在大段代码甚至整个方法上使用synchronize进行互斥。虽然这种方法能实现线程安全的代码，但是通常由于排斥时间太长而限制了并行性，从而造成性能低下。

用synchronize实现消费者生产者

package com.producerconsumer;

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

public class ProducerConsumerInJava {
    public static void main(String args[]) {
        System.out.println("How to use wait and notify method in Java");
        System.out.println("Solving Producer Consumper Problem");

        Queue<Integer> buffer = new LinkedList<>();
        int maxSize = 10;

        Thread producer = new Producer(buffer, maxSize, "PRODUCER");
        Thread consumer = new Consumer(buffer, maxSize, "CONSUMER");

        producer.start();
        consumer.start();

    }
}

/**
 * Producer Thread will keep producing values for Consumer to consumer. It will
 * use wait() method when Queue is full and use notify() method to send
 * notification to Consumer Thread.
 * 
 */
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) {
                    try {
                        System.out.println("Queue is full, " + "Producer thread waiting for "
                                + "consumer to take something from queue");
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }

                Random random = new Random();
                int i = random.nextInt();
                System.out.println("Producing value : " + i);
                queue.add(i);
                queue.notifyAll();
            }

        }
    }

}

/**
 * Consumer Thread will consumer values form shared queue. It will also use
 * wait() method to wait if queue is empty. It will also use notify method to
 * send notification to producer thread after consuming values from queue.
 * 
 */
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," + "Consumer thread is waiting"
                            + " for producer thread to put something in queue");
                    try {
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }

                }
                System.out.println("Consuming value : " + queue.remove());
                queue.notifyAll();
            }

        }
    }
}

用ReentrantLock实现消费者生产者

package com.toc;

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 TestReentrantLock {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("How to use await and signal method in Java");
        System.out.println("Solving Producer Consumper Problem");
        // 锁对象
        final Lock lock = new ReentrantLock();
        Condition full = lock.newCondition();
        Condition empty = lock.newCondition();

        Queue<Integer> buffer = new LinkedList<>();
        int maxSize = 10;

        Thread producer = new Producer(lock, full, empty, buffer, maxSize, "PRODUCER");
        Thread consumer = new Consumer(lock, full, empty, buffer, maxSize, "CONSUMER");

        producer.start();
        consumer.start();
    }
}

class Producer extends Thread {
    // 锁对象
    private final Lock lock;
    // 控制队列满的条件变量
    private final Condition full;
    // 控制队列空的条件变量
    private final Condition empty;
    private Queue<Integer> queue;
    private int maxSize;

    public Producer(Lock lock,Condition full,Condition empty, Queue<Integer> queue, int maxSize, String name) {
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
        this.lock = lock;
        this.full = full;
        this.empty = empty;
    }

    @Override
    public void run() {
        while(true){
            // 获得锁  
            lock.lock();
            try {
                while (queue.size() == maxSize) {
                    System.out.println("队列满了,等待消费者取走");
                    // 由于条件不满足，生产阻塞 
                    full.await();
                }
                Random random = new Random();
                int i = random.nextInt();
                System.out.println("Producing value : " + i);
                queue.add(i);
                empty.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

class Consumer extends Thread {
    // 锁对象
    private final Lock lock;
    // 控制队列满的条件变量
    private final Condition full;
    // 控制队列空的条件变量
    private final Condition empty;
    private Queue<Integer> queue;
    private int maxSize;

    public Consumer(Lock lock,Condition full,Condition empty, Queue<Integer> queue, int maxSize, String name) {
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
        this.lock = lock;
        this.full = full;
        this.empty = empty;
    }

    @Override
    public void run() {
        // 获得锁  
        while (true) {
            lock.lock();
            try{
                while (queue.isEmpty()) {
                    System.out.println("队列空了,等待生产者生产");
                    empty.await();
                }
                System.out.println("Consuming value : " + queue.remove());
                full.signal();
            }catch(InterruptedException e){
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
    }
}