Java多线程之并发协做生产者消费者设计模式

时间  2019-11-30
标签 java 多线程 并发 生产者 消费者 设计 模式 栏目 Java 繁體版
原文   原文链接

转载请注明出处：blog.csdn.net/linglongxin…java

两个线程一个生产者个一个消费者

需求情景

  • 两个线程，一个负责生产，一个负责消费，生产者生产一个，消费者消费一个

涉及问题

  • 同步问题：如何保证同一资源被多个线程并发访问时的完整性。经常使用的同步方法是采用标记或加锁机制api

  • wait() / nofity() 方法是基类Object的两个方法，也就意味着全部Java类都会拥有这两个方法，这样，咱们就能够为任何对象实现同步机制。并发

  • wait()方法：当缓冲区已满/空时，生产者/消费者线程中止本身的执行，放弃锁，使本身处于等等状态，让其余线程执行。ide

  • notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其余等待的线程发出可执行的通知，同时放弃锁，使本身处于等待状态。测试

代码实现（共三个类和一个main方法的测试类）

  • Resource.java
/** * Created by yuandl on 2016-10-11./** * 资源 */
public class Resource {
    /*资源序号*/
    private int number = 0;
    /*资源标记*/
    private boolean flag = false;

    /** * 生产资源 */
    public synchronized void create() {
        if (flag) {//先判断标记是否已经生产了，若是已经生产，等待消费；
            try {
                wait();//让生产线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;//生产一个
        System.out.println(Thread.currentThread().getName() + "生产者------------" + number);
        flag = true;//将资源标记为已经生产
        notify();//唤醒在等待操做资源的线程（队列）
    }

    /** * 消费资源 */
    public synchronized void destroy() {
        if (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName() + "消费者****" + number);

        flag = false;
        notify();
    }
}复制代码
  • Producer.java
/** * Created by yuandl on 2016-10-11. * /** * 生产者 */

public class Producer implements Runnable {
    private Resource resource;

    public Producer(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.create();
        }

    }
}复制代码
  • Consumer.java
/** * 消费者 */
public class Consumer implements Runnable {
    private Resource resource;

    public Consumer(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.destroy();
        }

    }
}复制代码
  • ProducerConsumerTest.java
/** * Created by yuandl on 2016-10-11. */
public class ProducerConsumerTest {
    public static void main(String args[]) {
        Resource resource = new Resource();
        new Thread(new Producer(resource)).start();//生产者线程
        new Thread(new Consumer(resource)).start();//消费者线程

    }

}复制代码
  • 打印结果
Thread-0生产者------------1
Thread-1消费者****1
Thread-0生产者------------2
Thread-1消费者****2
Thread-0生产者------------3
Thread-1消费者****3
Thread-0生产者------------4
Thread-1消费者****4
Thread-0生产者------------5
Thread-1消费者****5
Thread-0生产者------------6
Thread-1消费者****6
Thread-0生产者------------7
Thread-1消费者****7
Thread-0生产者------------8
Thread-1消费者****8
Thread-0生产者------------9
Thread-1消费者****9
Thread-0生产者------------10
Thread-1消费者****10复制代码

以上打印结果能够看出没有任何问题this

多个线程，多个生产者和多个消费者的问题

需求情景

  • 四个线程，两个个负责生产，两个个负责消费，生产者生产一个，消费者消费一个

涉及问题

  • notifyAll()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其余等待的全部线程发出可执行的通知，同时放弃锁，使本身处于等待状态。

再次测试代码

  • ProducerConsumerTest.java
/** * Created by yuandl on 2016-10-11. */
public class ProducerConsumerTest {
    public static void main(String args[]) {
        Resource resource = new Resource();
        new Thread(new Consumer(resource)).start();//生产者线程
        new Thread(new Consumer(resource)).start();//生产者线程
        new Thread(new Producer(resource)).start();//消费者线程
        new Thread(new Producer(resource)).start();//消费者线程

    }

}复制代码
  • 运行结果
Thread-0生产者------------100
Thread-3消费者****100
Thread-0生产者------------101
Thread-3消费者****101
Thread-2消费者****101
Thread-1生产者------------102
Thread-3消费者****102
Thread-0生产者------------103
Thread-2消费者****103
Thread-1生产者------------104
Thread-3消费者****104
Thread-1生产者------------105
Thread-0生产者------------106
Thread-2消费者****106
Thread-1生产者------------107
Thread-3消费者****107
Thread-0生产者------------108
Thread-2消费者****108
Thread-0生产者------------109
Thread-2消费者****109
Thread-1生产者------------110
Thread-3消费者****110复制代码
  • 经过以上打印结果发现问题
    • 101生产了一次，消费了两次
    • 105生产了，而没有消费

  • 缘由分析spa

    • 当两个线程同时操做生产者生产或者消费者消费时，若是有生产者或者的两个线程都wait()时，再次notify(),因为其中一个线程已经改变了标记而另一个线程再次往下直接执行的时候没有判断标记而致使的。
    • if判断标记，只有一次，会致使不应运行的线程运行了。出现了数据错误的状况。
  • 解决方案
    • while判断标记，解决了线程获取执行权后，是否要运行！也就是每次wait()后再notify()时先再次判断标记

代码改进（Resource中的if->while）

  • Resource.java
/** * Created by yuandl on 2016-10-11./** * 资源 */
public class Resource {
    /*资源序号*/
    private int number = 0;
    /*资源标记*/
    private boolean flag = false;

    /** * 生产资源 */
    public synchronized void create() {
        while (flag) {//先判断标记是否已经生产了，若是已经生产，等待消费；
            try {
                wait();//让生产线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;//生产一个
        System.out.println(Thread.currentThread().getName() + "生产者------------" + number);
        flag = true;//将资源标记为已经生产
        notify();//唤醒在等待操做资源的线程（队列）
    }

    /** * 消费资源 */
    public synchronized void destroy() {
        while (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName() + "消费者****" + number);

        flag = false;
        notify();
    }
}复制代码

运行结果

  • 再次发现问题 .net

    • 打印到某个值好比生产完74，程序运行卡死了，好像锁死了同样。

  • 缘由分析线程

    • notify:只能唤醒一个线程，若是本方唤醒了本方，没有意义。并且while判断标记+notify会致使"死锁"。

  • 解决方案code

    • notifyAll解决了本方线程必定会唤醒对方线程的问题。

最后代码改进（Resource中的notify()->notifyAll()）

  • Resource.java
/** * Created by yuandl on 2016-10-11./** * 资源 */
public class Resource {
    /*资源序号*/
    private int number = 0;
    /*资源标记*/
    private boolean flag = false;

    /** * 生产资源 */
    public synchronized void create() {
        while (flag) {//先判断标记是否已经生产了，若是已经生产，等待消费；
            try {
                wait();//让生产线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;//生产一个
        System.out.println(Thread.currentThread().getName() + "生产者------------" + number);
        flag = true;//将资源标记为已经生产
        notifyAll();//唤醒在等待操做资源的线程（队列）
    }

    /** * 消费资源 */
    public synchronized void destroy() {
        while (!flag) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName() + "消费者****" + number);

        flag = false;
        notifyAll();
    }
}复制代码
  • 运行结果
Thread-0生产者------------412
Thread-2消费者****412
Thread-0生产者------------413
Thread-3消费者****413
Thread-1生产者------------414
Thread-2消费者****414
Thread-1生产者------------415
Thread-2消费者****415
Thread-0生产者------------416
Thread-3消费者****416
Thread-1生产者------------417
Thread-3消费者****417
Thread-0生产者------------418
Thread-2消费者****418
Thread-0生产者------------419
Thread-3消费者****419
Thread-1生产者------------420
Thread-2消费者****420复制代码

以上就大功告成了，没有任何问题

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程