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

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

转载于:https://www.cnblogs.com/cenzhongman/p/7307743.html