生产者与消费者问题（两种方法实现）
场景：
生产者（Producer）生产产品,送到中间商（Medium）那里，消费者（Customer）从中间商那里取走产品，中间商只能持有一定数量的产品（如：30），如果中间商那里已经有了30个产品，中间商会通知生产者等一下，店中有空位置放产品时，通知生产者继续生产，如果中间商那里没有产品了，会通知消费者等一下，中间商有产品了，通知消费者继续消费。
Synchronized方法实现生产者消费者问题：
涉及到的线程间通信的方法
wait
导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。当前的线程必须拥有该对象的监视器。 该线程释放此监视器的所有权，并等待另一个线程通知等待该对象监视器的线程通过调用notify方法或notifyAll方法notifyAll方法 。 然后线程等待，直到它可以重新获得监视器的所有权并恢复执行。
notify
唤醒正在等待对象监视器的单个线程。 如果任何线程正在等待这个对象，其中一个被选择被唤醒。 选择是任意的，并且由实施的判断发生。 线程通过调用wait方法之一等待对象的监视器。调用notify后，当前线程不会马上释放该对象锁，要等到程序退出同步块后，当前线程才会释放锁。
notifyAll
该方法与 notify ()方法的工作方式相同，重要的一点差异是：
notifyAll 使所有原来在该对象上 wait 的线程统统退出等待状态，使得他们全部从等待队列中移入到同步队列中去，等待下一次能够有机会获取到对象监视器锁。
代码
/**
* 中间商
*/
public class Medium {
private int num = 0;
private static final int TOTAL = 30;
/**
* 接收生产数据
*/
public synchronized void put() {
if (num < TOTAL) {
System.out.println(Thread.currentThread() + "增加库存--------当前库存" + ++num);
notifyAll();
} else {
System.out.println(Thread.currentThread() + "增加库存--------库存已满" + num);
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 获取消费者数据
*/
public synchronized void take() {
if (num > 0) {
System.out.println(Thread.currentThread() + "消费库存--------当前库存" + --num);
notifyAll();
} else {
System.out.println(Thread.currentThread() + "消费库存--------库存不足" + num);
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 生产者
*/
public class Producer implements Runnable{
private Medium medium;
public Producer(Medium medium) {
this.medium = medium;
}
@Override
public void run() {
while (true) {
medium.put();
}
}
}
/**
* 消费者
*/
public class Consumer implements Runnable {
private Medium medium;
public Consumer(Medium medium) {
this.medium = medium;
}
@Override
public void run() {
while (true) {
medium.take();
}
}
}
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 测试类
*/
public class Main {
public static void main(String[] agrs) {
Medium medium = new Medium();
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20, 3L, TimeUnit.SECONDS,new LinkedBlockingQueue<>(20), new ThreadPoolExecutor.DiscardOldestPolicy());
threadPoolExecutor.prestartAllCoreThreads();
for (int i = 0; i < 5; i++){
threadPoolExecutor.submit(new Producer(medium));
}
for (int i = 0; i < 10; i++){
threadPoolExecutor.submit(new Consumer(medium));
}
}
}
Lock方法实现生产者消费者问题：
涉及到的方法
lock
需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个。
ReentrantLock
ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。
代码
/**
* 中间商
*/
public class Medium {
private int num = 0;
private static final int TOTAL = 30;
private Lock lock = new ReentrantLock();
private Condition consumerCondition = lock.newCondition();
private Condition producerCondition = lock.newCondition();
/**
* 接收生产数据
*/
public void put() {
lock.lock();
try {
if (num < TOTAL) {
System.out.println(Thread.currentThread() + "增加库存--------当前库存" + ++num);
consumerCondition.signalAll();
} else {
System.out.println(Thread.currentThread() + "增加库存--------库存已满" + num);
try {
producerCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
lock.unlock();
}
}
/**
* 获取消费者数据
*/
public void take() {
lock.lock();
try {
if (num > 0) {
System.out.println(Thread.currentThread() + "消费库存--------当前库存" + --num);
producerCondition.signalAll();
} else {
System.out.println(Thread.currentThread() + "消费库存--------库存不足" + num);
try {
consumerCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
lock.unlock();
}
}
}
/**
* 生产者
*/
public class Producer implements Runnable{
private Medium medium;
public Producer(Medium medium) {
this.medium = medium;
}
@Override
public void run() {
while (true) {
medium.put();
}
}
}
/**
* 消费者
*/
public class Consumer implements Runnable {
private Medium medium;
public Consumer(Medium medium) {
this.medium = medium;
}
@Override
public void run() {
while (true) {
medium.take();
}
}
}
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 测试类
*/
public class Main {
public static void main(String[] agrs) {
Medium medium = new Medium();
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20, 3L, TimeUnit.SECONDS,new LinkedBlockingQueue<>(20), new ThreadPoolExecutor.DiscardOldestPolicy());
threadPoolExecutor.prestartAllCoreThreads();
for (int i = 0; i < 5; i++){
threadPoolExecutor.submit(new Producer(medium));
}
for (int i = 0; i < 10; i++){
threadPoolExecutor.submit(new Consumer(medium));
}
}
}
Synchronized和lock用途区别
Synchronized语句和ReentrantLock在一般情况下区别不大，但是在非常复杂的同步应用中和需要实现公平锁功能时，请考虑使用ReentrantLock。