线程并发协作(生产者/消费者模式)

\quad 多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。
\quad 生产者指的是负责生产数据的模块(这里模块可能是：方法、对象、线程、进程)。
\quad 消费者指的是负责处理数据的模块(这里模块可能是：方法、对象、线程、进程)。
\quad 消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

实现线程的并发协作

\quad 有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况;同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。

解耦了生产者和消费者

\quad 生产者不需要和消费者直接打交道。

解决忙闲不均，提高效率

\quad 生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费;消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据 。

两种实现方式

管程法

public class CoTest01 {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread {
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        //生产
        for (int i = 0; i < 100; i++) {
            System.out.println("生产-->第"+i+"个馒头");
            container.push(new Steamedbun(i));
        }
    }
}
//消费者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        //消费
        for (int i = 0; i < 100; i++) {
            System.out.println("消费-->第"+container.pop().id+"个馒头");
        }
    }
}
//缓冲区
class SynContainer {
    Steamedbun[] buns = new Steamedbun[10];
    int count;

    //存储 生产
    public synchronized void push(Steamedbun bun) {
        //何时能生产 容器存在空间
        if(count == buns.length) {
            try {
                this.wait();  //线程阻塞 消费者通知生产 解除阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        buns[count++] = bun;
        //存在数据 可以通知消费者了
        this.notifyAll();
    }

    //获取
    public synchronized Steamedbun pop() {
        //何时消费 容器中是否存在数据
        //没有数据 等待
        if(count == 0) {
            try {
                this.wait();  //线程阻塞 生产者通知消费 解除阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Steamedbun bun = buns[--count];
        this.notifyAll();  //存在空间了 唤醒生产者
        return bun;
    }
}

class Steamedbun {
    int id;

    public Steamedbun(int id) {
        this.id = id;
    }
}
//数据

信号灯法

public class CoTest02 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//生产者 演员
class Player extends Thread {
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i % 2 == 0)
                tv.play("奇葩说");
            else
                tv.play("太污了，喝瓶立白洗洗嘴");
        }
    }
}
//消费者 观众
class Watcher extends Thread {
    Tv tv;

    public Watcher(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
//同一个资源 电视
class Tv {
    String voice;
    //信号灯
    //T 表示演员表演 观众等待
    //F 表示观众观看 演员等待
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        //演员等待
        if(!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("表演了:"+voice);
        this.voice = voice;
        //唤醒
        this.notifyAll();
        flag = !flag;
    }
    //观看
    public synchronized void watch() {
        //观众等待
        if(flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("听到了:"+voice);
        this.notifyAll();
        flag = !flag;
    }
}

线程并发协作总结：

线程并发协作(也叫线程通信)，通常用于生产者/消费者模式，情景如下：

  1. 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

  2. 对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。

  3. 对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。

  4. 在生产者消费者问题中，仅有synchronized是不够的。

    · synchronized可阻止并发更新同一个共享资源，实现了同步;

    · synchronized不能用来实现不同线程之间的消息传递(通信)。

  5. 那线程是通过哪些方法来进行消息传递(通信)的呢?见如下总结：

6. 以上方法均是java.lang.Object类的方法;

都只能在同步方法或者同步代码块中使用，否则会抛出异常。