Java线程 生产者消费者问题

最新推荐文章于 2021-02-12 17:25:08 发布
最新推荐文章于 2021-02-12 17:25:08 发布
阅读量320 收藏
点赞数
分类专栏： Java 文章标签： 进程与线程 线程状态 生产者与消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010094934/article/details/52681266
版权

Java线程创建

  继承 Java.lang.Thread 类  劣势:无法继承其他类

  实现 Runnable接口    优势:可以让线程处理同一个资源 实现线程间的资源共享

Java线程状态

新建状态 

 使用new关键字和Thread类创建线程对象后 线程对象就处于新生状态    通过调用start()方法进入就绪状态

 不能对已经启动的线程再次调用start()方法 否则会出现 java.lang.IllegalThreadStateException异常

就绪状态

  线程位于可运行池中  cpu会在线程池中进行调度  一旦线程获取cpu 进入运行状态 就会自动调用run方法、

运行状态  

 如果线程在运行状态中失去了cpu资源，就会变为就绪状态

 如果线程调用sleep()方法  wait()方法  阻塞式的io方法 等会进入阻塞状态 

 run()方法执行完 stop  

出现error或者exception  退出 

阻塞状态

 线程让出cpu并且暂停自己的运行，进入阻塞状态

 在阻塞状态的线程不能进入就绪队列，只有当阻塞状态解除时才会重新进入就绪状态

死亡状态

  线程中的run方法执行完毕 或者强制性终止 就认为已经进入了死亡状态   死亡状态的线程不能执行 


生产者消费者问题

  生产者的主要作用是 生成一定量的数据放到缓冲区中

  消费者的主要作用是 在缓冲区中消耗这些数据  

  生产者不断的生产  消费者不断的消费

  问题关键：生产者不会在缓冲区满时加入数据    消费者不会在缓冲区空时消耗数据

  解决策略：生产者在缓冲区满时休眠  消费者在缓冲区空时休眠   利用线程间的通信解决问题

  线程成为对象monitor的三种方式

      通过执行该对象的同步实例方法

      通过执行一个同步的声明对象

      通过执行同步静态方法

   一个线程在同一时刻可以拥有一个对象monitor

 方法一  利用Object类中的 wait 和notify  notifyAll解决问题

     Object  public final void wait()    使拥有该对象的monitor的当前进程等待    直到另一个线程调用该对象的notify() notifyall() 方法重新获得monitor  并恢复执行

     Object  public final void notify()  唤醒一个 在该对象上等待的  一个进程  如果有多个 则任意

     Object  public final void notifyAll() 唤醒所有 在该对象上等待 的所有进程

  方法二  利用java.util.concurrent 下的await()  signal() 方法解决生产者消费者问题

                         java.util.concurrent.locks.ReentrantLock    

              Condition();  返回此锁使用的条件实例

             lock();获取锁  如果不是由另一个线程持有 则立即返回 计数保持为1  当前线程已持有锁  计数递增 立即返回   如果锁 由另一个线程持有  则当前线程休眠 知道锁被收回

              unlock();释放锁  如果当前线程持有锁  计数减少   如果计数为0则释放锁  如果当前线程不是锁的拥有者 抛出异常

             await();等待发出信号或者中断当前进程  当其他某个线程调用signal() signalall()  

  定义抽象接口

   public  interface  Storage extends Runnable(){

       public  void  produce(int n);   //生产 方法

       public  void  consume(int n);// 消费  方法

   }

  实现抽象接口类 方法一StorageOne

    package producerConsumer;


import java.util.LinkedList;

public class StorageOne implements Storage{
    

private final int MAX_SIZE=100;  //仓库大小

private LinkedList<Object> list=new LinkedList<Object>(); //仓库

public LinkedList<Object> getList() {
return list;
}


public void setList(LinkedList<Object> list) {
this.list = list;
}


public int getMAX_SIZE() {
return MAX_SIZE;
}


//生产num个产品
public void produce(int num){
//使用 synchronized 代码块    保证同一时刻只有一个线程执行该代码
synchronized (list){
if (list.size()+num > MAX_SIZE){
System.out.println("当前库存为  "+list.size()+" 无法生产 "+num+" 个商品");
try {
list.wait();
} catch (InterruptedException e) {  
e.printStackTrace();
}

}
for(int i=1;i<=num;++i){
list.add(new Object());
}
System.out.println("当前库存为 "+list.size()+" 已经生产 "+num+" 个商品");
list.notifyAll();
}
}

//消费num个商品 
public void consume(int num){
       synchronized(list) {
      if(list.size()<num)
      {
      System.out.println("当前库存为  "+list.size()+" 无法消费 "+num+" 个商品");
      try {
list.wait();
  } catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
  }
      }
      for(int i=1;i<=num;++i){
      list.remove();
      }
      System.out.println("当前库存为  "+list.size()+" 已经消费 "+num+" 个商品");
      list.notifyAll();
       }
}
}

实现抽象接口类  方法二  StorageTwo

  package producerConsumer;
import java.util.LinkedList;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  /**
   * synchronized缺陷   当一个线程执行该代码块时 如果时间过长    除非出现异常 或者执行完毕   其他线程也只能等待释放该资源      影响程序效率
   * lock  通过lock实现同步访问  可以让等待的进程相应中断 也可让线程知道是否获得锁   但必须用户手动释放锁 防止发生死锁
   * Condition依赖于Lock接口  在lock与unlock中   才可以使用
   * @author inewline
   *
   */


public class StorageTwo  implements Storage
{  
    private final int MAX_SIZE = 100;   //仓库大小
  
    private LinkedList<Object> list = new LinkedList<Object>();  //仓库
  
    private final Lock lock = new ReentrantLock();  //锁
  
    private final Condition full = lock.newCondition();      // 仓库满的条件变量  
  
    private final Condition empty = lock.newCondition();     // 仓库空的条件变量   
    
    public int getMAX_SIZE()  
    {  
        return MAX_SIZE;  
    }  
  
    public LinkedList<Object> getList()  
    {  
        return list;  
    }  
  
    public void setList(LinkedList<Object> list)  
    {  
        this.list = list;  
    }  
    
    // 生产num个产品  
    public void produce(int num)       
    {  
        lock.lock();      // 获得锁  
  
        // 如果仓库剩余容量不足  
        while (list.size() + num > MAX_SIZE)  
        {  
        System.out.println("当前库存为"+list.size()+"无法生产"+num+"个商品");
            try  
            {  
                // 由于条件不满足，生产阻塞  
                full.await();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }    
        // 生产条件满足情况下，生产num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            list.add(new Object());  
        }  
        System.out.println("已经生产了"+num+"当前库存为"+list.size()); 
  
        // 唤醒其他所有线程  
        full.signalAll();  
        empty.signalAll();  
  
        // 释放锁  
        lock.unlock();  
    }  
  
    // 消费num个产品  
    public void consume(int num)  
    {  
        // 获得锁  
        lock.lock();  
  
        // 如果仓库存储量不足  
        while (list.size() < num)  
        {  
            System.out.println("当前库存为"+list.size()+"无法消费"+num+"个商品");
            try  
            {  
                // 由于条件不满足，消费阻塞  
                empty.await();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
  
        // 消费条件满足情况下，消费num个产品  
        for (int i = 1; i <= num; ++i)  
        {  
            list.remove();  
        }  
   
        System.out.println("已经消费了"+num+"当前库存为"+list.size());
  
        // 唤醒其他所有线程  
        full.signalAll();  
        empty.signalAll();  
  
        // 释放锁  
        lock.unlock();  
    }  
  


}

  生产者线程

  sleep()方法  位于thread类下的 public staticvoid sleep(long millis){ } 当前正在执行的线程休眠 （暂停执行）的指定毫秒数  线程不失去任何对象monitors的所有权

   package producerConsumer;

public class Producer extends Thread  {
    private int num;
    private Storage storage;
    
    public Storage getstorage() {
return storage;
}
public void setstorage(Storage storage) {
this.storage = storage;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}

    public Producer(Storage storage){
    this.storage=storage;
    }
    public void produce(int num){
    storage.produce(num);
    }
    public void run(){
    while(true){
     try {
Producer.sleep(1000);   
} catch (InterruptedException e) {
e.printStackTrace();
}
     produce(num);
    }
    }
}

  消费者线程

package producerConsumer;
public class Consumer extends Thread   {
    private int num;
    private Storage storage;
    public Consumer(Storage storage){
    this.storage=storage;
    }
    public int getNum() {
  return num;
    }
public void setNum(int num) {
this.num = num;
}
public Storage getstorage() {
return storage;
}
public void setstorage(Storage storage) {
this.storage = storage;
}
    public void consume(int num){
    storage.consume(num);
    }
    public void run(){
    while(true){
     try {
Consumer.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
          consume(num);
    }  
    }
}

测试程序调用   mainTest

     Storage storage=new StorageOne();

      //Storage storage=new StorageTwo();
      Producer p1 = new Producer(storage);  
       Producer p2 = new Producer(storage);  
       Producer p3 = new Producer(storage);  
       Producer p4 = new Producer(storage);  

       
       Consumer c1 = new Consumer(storage);  
       Consumer c2 = new Consumer(storage);  
       Consumer c3 = new Consumer(storage); 
       Consumer c4 = new Consumer(storage);
       
       p1.setNum(10);  
       p2.setNum(20);  
       p3.setNum(30);  
       p4.setNum(40);  
 
       
       c1.setNum(70);  
       c2.setNum(20);  
       c3.setNum(30);
       c4.setNum(40);
       
       c1.start();  
       c2.start();  
       c3.start(); 
       c4.start();
       
       p1.start();  
       p2.start();  
       p3.start();  
       p4.start();  

吾会飞飞飞
关注
专栏目录
Java——线程之生产者消费者
smile4548656的博客
04-24 1446
Java——线程之生产者消费者一、生产者消费者模式概述二、生产者消费者案例 一、生产者消费者模式概述 生产者消费者模式是一个经典的多线程协作的模式。生产者消费者问题主要包含两类线程： 生产者线程：生产数据 消费者线程：消费数据 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库： 生产者生成数据后直接放置在共享数据区中，并不需要关心消费者的行为 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为 为了体现生产和消费过程中的等待和唤醒，Java提供了几个方法，这几个方
JAVA多线程之生产者消费者问题
ckbhdx的博客
08-24 276
JAVA多线程之生产者消费者问题
Java线程——生产者消费者
tbc123tbc的博客
12-25 210
下面举一个两个线程共享同一个数据的例子。 先用一幅图来说明这个消费者生产者关系 ProductList是一个生产者跟消费者共享的同步机制，这个机制决定了什么情况生产者要wait(), 什么情况消费者要wait()。可以把ProductList看做一个产品仓库．当产品仓库满的时候，生产者线程需要wait()，从而放弃对产品仓库的控制。这个时候消费者线程就可以进来了且取得仓库的控制权。一旦消费者消
java多线程篇-生产者消费者问题
linry的博客
09-04 310
*前言 生产者消费者问题是java多线程中五个同步问题的经典模型之。   问题描述： 生产者生产产品，消费者消费产品，可以有一个或多个生产者生产产品供一个或多个消费者消费产品。 为使生产与消费并发，在生产者和消费者之间建立共享的缓冲区，生产者生产的产品放入缓冲区，消费者从缓冲区中消费产品。 生产者与消费者需保持同步，生产者不能在缓冲区已满时继续生产，消费者不能在缓冲区为空时消费产品。 ...
java 线程生产者消费者
我需要懂得努力
12-08 1081
public class Test_Producer_Consumer { public static void main(String[] args) { Resource res = new Resource(); Producer pro = new Producer(res); Consumer con = new Consumer(res); Thread t1 =
Java多线程技术~生产者和消费者问题
热门推荐
qq_41424688的博客
06-16 3万+
Java多线程技术~生产者和消费者问题 本文是上一篇文章的后续,详情点击该连接 线程通信 应用场景：生产者和消费者问题        假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费        如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止    &
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者的实例详解 JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费...
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种...
Java多线程 生产者消费者模型实例详解
08-25
Java多线程生产者消费者模型实例详解 Java多线程生产者消费者模型是指在多线程环境下，生产者线程生产任务，消费者线程消费任务，而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者...
Java多线程-生产者与消费者问题
最新发布
02-03
### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景：一个是生产者...
java多线程实现生产者消费者问题
12-08
用java多线程，实现生产者消费者同步和互斥的问题，操作系统中的经典问题
Java多线程实现生产者消费者
05-29
编写一个“生产者-消费者”的多线程演示程序，两个生产者，一个消费者，可以存放产品的仓库容量为10，仓库用栈实现，并有同步功能，且能防止先消费后生产的情况。
Java——生产者-消费者问题
12-21
总结来说，这个Java程序通过使用信号量和多线程技术，生动地演示了解决"生产者-消费者"问题的过程。它不仅展示了如何在Java中实现线程同步，还通过图形界面和随机休眠策略来模拟现实生活中的并发挑战，这对于理解和...
java线程之生产者消费者
GS2016的博客
03-26 219
package test; public class ThreadTest { public static void main(String args[]){ Resource r = new Resource(); Product p = new Product(r); Consume c = new Consume(r); Thread tp = new Thread(p...
java线程（生产者/消费者）
qq_25877301的博客
12-19 286
import java.util.ArrayList; import java.util.List; /**  * 消费者/生产者模式 问题：  *  1.一个共同容量确定的仓库，  *  2.生产者只管生产物品放到仓库，若仓库库满则等待，若库未满，继续生产放入，  *  3.消费者只管从仓库区物品，若库空则等待，若库未空，则取  *  4.消费者和生产者，相互不关联
java多线程-经典生产者消费者问题
秋楓的博客
03-25 212
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争 ———————————————— 版权声明：本文为CSDN博主「djzhao」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链
java多线程 生产者消费者_Java多线程之生产者消费者
weixin_35661054的博客
02-12 210
你们既从罪里得了释放，就做了义的奴仆。---罗马书6:18概念介绍生产者--消费者模型是多线程运用的经典案例，其设定了这样一个场景，生产者消费者分属两个不同线程，但它们都共同拥有一个数据缓冲区，这个缓冲区用来平衡生产者消费者处理数据不同步的问题。拿生活中的例子举例，比如我们去餐馆吃饭，餐馆出菜的速度不一致，前来餐馆的消费者也时多时少，为了减少消费者等待上菜的时间，餐馆在消费者还没有点菜的时候提前就...
java线程：生产者消费者模式(管程法)
卫卫的博客
05-29 184
组成 商品(Shop) 仓库(Warehouse：存储商品) 生产者(Producer：生产商品，当仓库容量不够时等待消费者消费商品)； 消费者(Consumer：消费者，当仓库数量不够时等待生产者生产商品)； 生产者 /** * 生产者 * @author Administrator * */ class Producer implements Runnable{ Warehous...
【JAVA多线程】如何解决一个生产者与消费者问题
阳阳的博客
11-01 1万+
如何解决一个生产者与消费者问题 生产者与消费者问题是多线程同步的一个经典问题。生产者和消费者同时使用一块缓冲区，生产者生产商品放入缓冲区，消费者从缓冲区中取出商品。我们需要保证的是，当缓冲区满时，生产者不可生产商品；当缓冲区为空时，消费者不可取出商品。 下面介绍java中几种解决同步问题的方式 （1）wait()与notify()方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值