jdk5.0 多线程学习笔记（三）

生产者-消费者模式解析

最新推荐文章于 2021-03-22 06:34:14 发布

最新推荐文章于 2021-03-22 06:34:14 发布 · 191 阅读

文章标签：

#多线程 #编程 #thread

java技术专栏收录该内容

46 篇文章

订阅专栏

本文介绍了生产者-消费者模式的基本概念及其实现方式。通过具体代码示例展示了如何使用该模式来解决不同线程间的数据传递问题，并讨论了线程间的同步与通信机制。

在进一步学习jdk5.0的多线程编程以前，先介绍一下生产者--消费者模式（producer-consumer）

生产者是指：生产数据的线程

消费者是指：使用数据的线程

生产者和消费者是不同的线程，他们处理数据的速度是不一样的，一般在二者之间还要加个“桥梁参与者”，用于缓冲二者之间处理数据的速度差。

下面用代码来说明：

//生产者
public class MakerThread extends Thread {
    private final Random random;
    private final Table table;
    private static int id = 0; 
    public MakerThread(String name, Table table, long seed) {
        super(name);
        this.table = table;//table就是桥梁参与者
        this.random = new Random(seed);
    }
    public void run() {
        try {
            while (true) {
                Thread.sleep(random.nextInt(1000));//生产数据要耗费时间
                String cake = "[ Cake No." + nextId() + " by " + getName() + " ]";//生产数据
                table.put(cake);//将数据存入桥梁参与者
            }
        } catch (InterruptedException e) {
        }
    }
    private static synchronized int nextId() {
        return id++;
    }
}

再来看看消费者：

//消费者线程
public class EaterThread extends Thread {
    private final Random random;
    private final Table table;
    public EaterThread(String name, Table table, long seed) {
        super(name);
        this.table = table;
        this.random = new Random(seed);
    }
    public void run() {
        try {
            while (true) {
                String cake = table.take();//从桥梁参与者中取数据
                Thread.sleep(random.nextInt(1000));//消费者消费数据要花时间
            }
        } catch (InterruptedException e) {
        }
    }
}

看来在这个模式里table是个很重要的角色啊，让我们来看看他吧（这里只给出个简单的）：

public class Table {
    private final String[] buffer;
    private int tail;  /下一个放put（数据）的地方 
    private int head;  //下一个那曲take（数据）的地方
    private int count; // buffer内的数据数量
    public Table(int count) {
        this.buffer = new String[count];//总量是确定的
        this.head = 0;
        this.tail = 0;
        this.count = 0;
    }
    // 放置数据
    public synchronized void put(String cake) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + " puts " + cake);
        while (count >= buffer.length) {//数据放满了就只能等待
            wait();
        }
        buffer[tail] = cake;
        tail = (tail + 1) % buffer.length;
        count++;
        notifyAll();//有数据了，唤醒线程去取数据
    }
    // 取得数据
    public synchronized String take() throws InterruptedException {
        while (count <= 0) {//没有数据就只能等待
            wait();
        }
        String cake = buffer[head];
        head = (head + 1) % buffer.length;
        count--;
        notifyAll();//有位置可以放数据了，唤醒线程，不等了
        System.out.println(Thread.currentThread().getName() + " takes " + cake);
        return cake;
    }
}i

好了我们来实验吧：

public class Main {
    public static void main(String[] args) {
        Table table = new Table(3);     // 建立可以放置数据的桥梁参与者，3是他所能放置的最大数量的数据。
        new MakerThread("MakerThread-1", table, 31415).start();//生产数据
        new MakerThread("MakerThread-2", table, 92653).start();
        new MakerThread("MakerThread-3", table, 58979).start();
        new EaterThread("EaterThread-1", table, 32384).start();//消费数据
        new EaterThread("EaterThread-2", table, 62643).start();
        new EaterThread("EaterThread-3", table, 38327).start();
    }
}

之所以在这里要介绍这个模式，是为了更好的理解jdk5的线程编程。