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

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();
}
}
}
}
}

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();
}

}
}
}