线程通信之生产者和消费者案例

使用 Object 类的 wait() 和 notify() 方法 （不适用锁机制）

只有同步监听对象才可以调用 wait() 和 notify() 方法，否则报错
线程之间进行通信，且防止耦合度过高，使用一个中间类作为通信的共同资源

• 需要使用 synchronized 保证一个过程的原子性
• 使用 isEmpty 变量作为标志参数，在结束生产和结束消费之后改变该值
• 使用 Object 类的 wait() 方法，判断资源状态，若存在则当前进程进入等待池
• 使用 Object 类的 notify() 方法，在结束生产和结束消费之后唤醒其他线程
• 值得注意的是：只有同步监听对象才可以调用 wait() 和 notify() 方法，否则报错

测试类

source 作为两个线程的参数传入

public class TestDemo {
public static void main(String[] args) {
ShareSources source = new ShareSources();
new Producer(source).start();
new Comsumer(source).start();
}
}

资源类

public class ShareSources {
private String name;
private String sex;
private Boolean isEmpty = true;//使用一个参数作为标志

/**
* 存入数据
* @param name
* @param sex
*/
synchronized public void push(String name, String sex) {//同步方法，保证了该方法的原子性
try {
//此处使用While比If更加合理，
while (!isEmpty) {// 生产者是当前线程，如果资源任存在，则当前线程释放锁，进入等待池中，释放后，消费者进程获得锁
this.wait();//this 指的是 source 对象 进入等待池中的线程只能被其他线程唤醒，这里只能在消费者线程中唤醒
}
//---------------------开始生产-------------------------
this.name = name;
Thread.sleep(10);
this.sex = sex;
//---------------------结束生产-------------------------
isEmpty = false;
this.notifyAll();//同时将其他线程唤醒
} catch (Exception e) {
e.printStackTrace();
}

}

/**
* 获取资源
*/
synchronized public void get() {
try {
while (isEmpty) {//如果资源不存在
this.wait();//当前线程是消费者，进入等待池
}
} catch (InterruptedException e) {
e.printStackTrace();
}
//---------------------开始消费-------------------------
Thread.sleep(10);
System.out.println(this.name + "-" + this.sex);
//---------------------结束消费-------------------------
isEmpty = true;
this.notifyAll();//同时将其他线程唤醒
}
}

生产者类

生产者可能存在多个，且需要与消费者不同线程

public class Producer extends Thread {
private ShareSources source = null;

public Producer(ShareSources source) {//通过构造器获取相同的资源
this.source = source;
}

@Override
public void run() {
for (int i = 0; i < 50; i++) {
if (i % 2 == 0) {
source.push("春哥", "男");
}else {
source.push("凤姐", "女");
}
}
}
}

消费者类

public class Comsumer extends Thread {
private ShareSources source = null;

public Comsumer(ShareSources source) {
this.source = source;
}

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

使用 Lock 和 condition 接口

资源类(只有该类发生变化)

需要注意的是，condition 的操作一定要在获取锁之后，释放锁之前执行，否则报错

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

public class ShareSources {
private String name;
private String sex;
private Boolean isEmpty = true;
// 实例化锁
private final Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();// 由于Condition是一个接口，lock.newCondition()方法返回一个绑定的Condition实例

/**
* 存入数据
*
* @param name
* @param sex
*/
public void push(String name, String sex) {
lock.lock();
try {
if (!isEmpty) {
condition.await();// 使用condition的await()方法相当于 Object 类的 wait 方法
}
this.name = name;
Thread.sleep(10);
this.sex = sex;
isEmpty = false;
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}

/**
* 获取资源
*/
public void get() {
lock.lock();
try {
if (isEmpty) {
condition.await();// 使用condition的await()方法相当于 Object 类的 wait 方法
}
Thread.sleep(10);
System.out.println(this.name + "-" + this.sex);
isEmpty = true;
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}