`

用java实现的生产者与消费者多线程同步互斥模型

    博客分类:
  • java
阅读更多

生产者与消费者模型中,要保证以下几点:
 (1)同一时间内只能有一个生产者生产。
 (2)同一时间内只能有一个消费者消费。
 (3)生产者生产的同时消费者不能消费。
 (4)消息队列满时生产者不能继续生产,消息队列空时消费者不能继续消费,此时必须等待。

代码:

1、Message.java

view plaincopy to clipboardprint?
package com.test;  
 
/** 
 * 消息对象 
 * 
 */ 
public class Message {  
 
    private int id;  
    private String message;  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getMessage() {  
        return message;  
    }  
    public void setMessage(String message) {  
        this.message = message;  
    }  
      
      

package com.test;

/**
 * 消息对象
 *
 */
public class Message {

 private int id;
 private String message;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getMessage() {
  return message;
 }
 public void setMessage(String message) {
  this.message = message;
 }
 
 
}
 

2、Queue.java

 view plaincopy to clipboardprint?
package com.test;  
 
import java.util.ArrayList;  
import java.util.List;  
/** 
 * 存放消息的缓存队列,共享资源 
 * 
 */ 
public class Queue {  
 
    private List<Message> list = new ArrayList<Message>();  
      
    private int maxCount = 5;  
      
    /** 
     * 生产 
     * @param message 
     */ 
    public synchronized void product(Message message){  
          
        this.notifyAll();  
        while (maxCount == getList().size()) {  
            System.out.println(Thread.currentThread().getName()+",队列已满,等待中。。。。");  
            try {  
                this.wait();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        getList().add(message);  
        System.out.println(Thread.currentThread().getName()+",正在生产。。。队列当前个数:"+getList().size());  
    }  
      
    /** 
     * 消费 
     */ 
    public synchronized void consume(){  
        this.notifyAll();  
        while(getList().size()==0){  
            System.out.println(Thread.currentThread().getName()+",队列为空,等待中。。。");  
            try {  
                this.wait();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        Message message = getList().get(0);  
        getList().remove(message);  
        System.out.println(Thread.currentThread().getName()+",正在消费。。。队列当前个数:"+getList().size());  
          
    }  
 
    public List<Message> getList() {  
        return list;  
    }  
 
    public void setList(List<Message> list) {  
        this.list = list;  
    }  
 
    public int getMaxCount() {  
        return maxCount;  
    }  
 
    public void setMaxCount(int maxCount) {  
        this.maxCount = maxCount;  
    }  

package com.test;

import java.util.ArrayList;
import java.util.List;
/**
 * 存放消息的缓存队列,共享资源
 *
 */
public class Queue {

 private List<Message> list = new ArrayList<Message>();
 
 private int maxCount = 5;
 
 /**
  * 生产
  * @param message
  */
 public synchronized void product(Message message){
  
  this.notifyAll();
  while (maxCount == getList().size()) {
   System.out.println(Thread.currentThread().getName()+",队列已满,等待中。。。。");
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  getList().add(message);
  System.out.println(Thread.currentThread().getName()+",正在生产。。。队列当前个数:"+getList().size());
 }
 
 /**
  * 消费
  */
 public synchronized void consume(){
  this.notifyAll();
  while(getList().size()==0){
   System.out.println(Thread.currentThread().getName()+",队列为空,等待中。。。");
   try {
    this.wait();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  Message message = getList().get(0);
  getList().remove(message);
  System.out.println(Thread.currentThread().getName()+",正在消费。。。队列当前个数:"+getList().size());
  
 }

 public List<Message> getList() {
  return list;
 }

 public void setList(List<Message> list) {
  this.list = list;
 }

 public int getMaxCount() {
  return maxCount;
 }

 public void setMaxCount(int maxCount) {
  this.maxCount = maxCount;
 }
}
 

3、Producer.java

view plaincopy to clipboardprint?
package com.test;  
 
import java.util.Random;  
 
/** 
 * 生产者生产 
 * 
 */ 
public class Producer implements Runnable {  
 
    private Queue queue = null;  
 
    public Producer(Queue queue) {  
        this.queue = queue;  
    }  
 
    public void run() {  
        while (true) {  
            Message message = new Message();  
            message.setId(new Random().nextInt());  
            message.setMessage("message," + new Random().nextInt());  
            queue.product(message);  
            try {  
                Thread.sleep(100);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
 
    }  
 

package com.test;

import java.util.Random;

/**
 * 生产者生产
 *
 */
public class Producer implements Runnable {

 private Queue queue = null;

 public Producer(Queue queue) {
  this.queue = queue;
 }

 public void run() {
  while (true) {
   Message message = new Message();
   message.setId(new Random().nextInt());
   message.setMessage("message," + new Random().nextInt());
   queue.product(message);
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }

 }

}
 

4、Consumer .java

view plaincopy to clipboardprint?
package com.test;  
 
/** 
 * 消费者消费 
 * 
 */ 
public class Consumer implements Runnable {  
 
    private Queue queue;  
 
    public Consumer(Queue queue) {  
        this.queue = queue;  
    }  
 
    public void run() {  
 
        while (true) {  
            queue.consume();  
            try {  
                Thread.sleep(100);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
 
    }  

package com.test;

/**
 * 消费者消费
 *
 */
public class Consumer implements Runnable {

 private Queue queue;

 public Consumer(Queue queue) {
  this.queue = queue;
 }

 public void run() {

  while (true) {
   queue.consume();
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }

 }
}
 

5、Test.java

view plaincopy to clipboardprint?
package com.test;  
 
public class Test {  
 
    public static void main(String[] args) {  
        Queue queue = new Queue();  
//      生产者两个  
        Producer producer1 = new Producer(queue);  
        Producer producer2 = new Producer(queue);  
          
//    消费者三个  
        Consumer consumer1 = new Consumer(queue);  
        Consumer consumer2 = new Consumer(queue);  
        Consumer consumer3 = new Consumer(queue);  
          
        Thread thread1 = new Thread(producer1,"producer1");  
        Thread thread2 = new Thread(producer2,"producer2");  
        Thread thread3 = new Thread(consumer1,"consumer1");  
        Thread thread4 = new Thread(consumer2,"consumer2");  
        Thread thread5 = new Thread(consumer3,"consumer3");  
        thread1.start();  
        thread2.start();  
        thread3.start();  
        thread4.start();  
        thread5.start();  
          
          
    }  

 

分享到:
评论

相关推荐

    java多线程实现生产者和消费者

    在并发编程中,"生产者-消费者"模式是一种经典的解决问题的范式,用于协调两个或更多线程间的协作,其中一部分线程(生产者)生成数据,另一部分线程(消费者)消费这些数据。 生产者-消费者模型的核心在于共享资源...

    生产者-消费者多线程处理

    总之,"生产者-消费者"多线程处理是一个核心的并发编程概念,它展示了如何在多线程环境中有效地管理和共享资源,以实现高效的程序执行。理解并正确实现这一模式对于任何从事并发编程或系统设计的IT专业人员来说都至...

    java实现生产者消费者

    在Java编程中,"生产者消费者"模式是一种典型的多线程问题解决模型,它通过共享资源来协调生产者和消费者之间的操作。这个模式的核心在于如何有效地管理资源的生产和消费,以避免生产过快导致资源浪费,或者消费者...

    线程间资源互斥与通信(生产者消费者)

    6. **Java并发库(java.util.concurrent)**:Java提供了强大的并发库,包括`BlockingQueue`接口和其实现如`ArrayBlockingQueue`,它们内置了线程安全的队列操作,使得生产者消费者模式的实现更为简洁。`...

    用多线程同步方法解决生产者-消费者问题

    在IT领域,多线程同步方法是解决并发编程中一种常见的问题,特别是在分布式系统和并发应用程序中。生产者-消费者问题是这种并发模型的一个经典案例,它涉及到如何在多个线程间共享资源,确保数据的一致性和正确性。...

    计算机操作系统实验-生产者和消费者(java)

    在 Java 中,我们可以使用多线程编程和同步机制来实现生产者-消费者模型。 生产者-消费者模型的定义 生产者-消费者模型是一种同步机制,用于解决多线程之间的数据共享和访问问题。生产者负责生产数据,并将其存储...

    线程同步--生产者消费者问题

    在Java编程中,"线程同步--生产者消费者问题"是一个经典的多线程问题,它涉及到如何有效地在多个线程之间共享资源。这个问题通常用于演示和理解线程间的协作机制,如互斥锁、条件变量等。在此,我们将深入探讨这个...

    生产者消费者线程问题

    生产者消费者线程问题是多线程编程中的一个经典模型,主要用来解决资源的同步与协作问题。在操作系统课程设计中,这个模型常被用来教授线程间的通信与同步机制,帮助学生理解进程间的协调和资源管理。以下是关于生产...

    生产者与消费者实验报告

    通过本次实验,我们不仅加深了对生产者与消费者模型的理解,还学会了如何在多线程环境中实现这一模型。此外,我们还掌握了如何使用条件变量和互斥锁等工具来解决多线程编程中常见的同步问题。未来的研究方向可能包括...

    生产者消费者演示程序

    生产者消费者问题是一个经典的多线程同步问题,来源于操作系统理论,用于模拟两个或多个相互依赖的进程或线程之间的协作。在这个场景下,“生产者”是生成数据的实体,而“消费者”则负责处理这些数据。这个问题的...

    线程同步生产者消费者问题解析

    "线程同步生产者消费者问题"是多线程编程中一个经典的示例,它涉及到资源的共享、线程间的协作以及等待条件的建立。以下是对这一问题的详细解析。 首先,我们需要了解"生产者消费者问题"的基本模型。在这个模型中,...

    生产者消费者问题和先来先服务算法

    在操作系统领域,生产者消费者问题是多线程编程中一个经典的同步问题,而先来先服务(First-Come, First-Served, FCFS)算法是调度策略的一种,它们都是理解并发控制和资源管理的重要概念。 生产者消费者问题描述的...

    生产者消费者源码(多线程)

    生产者消费者模型的核心在于同步和互斥,确保生产者不会在缓冲区满时继续添加数据,消费者也不会在缓冲区为空时尝试消费数据。在Java中,这通常通过`java.util.concurrent`包中的工具类实现,如`BlockingQueue`。 1...

    JAVA_生产者-消费者

    总结来说,"JAVA_生产者-消费者"是一个经典的并发编程模型,它利用Java的线程同步机制和`BlockingQueue`接口来实现高效的数据交换。理解并熟练掌握这一模式对于开发高并发、高性能的Java应用至关重要。通过学习和...

    生产者消费者多线程代码

    标题中的"生产者消费者多线程代码"指的是一个具体的实现,允许用户指定生产者和消费者的数量,并管理它们对临界资源的访问。在这样的系统中,生产者线程负责创建或生成数据(产品),并将数据放入缓冲区;而消费者...

    生产者与消费者实例代码,线程学习必备

    在Java或者其他支持多线程的编程语言中,生产者与消费者问题通常通过线程同步机制来解决,如互斥锁(Mutex)、信号量(Semaphore)或条件变量(Condition)。在这个模型中,"生产者"线程负责生成数据并将数据放入...

    操作系统课程设计多线程 生产者消费者问题

    操作系统课程设计中的“生产者-消费者问题”是一个经典的并发编程模型,主要用来演示如何在多线程环境下协调生产者和消费者的行为,以达到资源的有效利用和避免数据竞争。在这个Java实现的小程序中,我们将深入探讨...

    生产者和消费者问题以及哲学家就餐问题,JAVA实现的程序.rar

    在"生产者和消费者问题.txt"文件中,可能包含了使用`BlockingQueue`实现生产者消费者问题的Java代码示例,包括如何创建队列,以及生产者和消费者线程如何交互。而"哲学家就餐问题.txt"文件可能展示了如何用Java的...

    用点菜和吃菜来做模拟(生产者和消费者的多线程关系)

    本文将通过一个生动的比喻——“点菜与吃菜”来解释生产者和消费者模型,这是一类典型的多线程问题。我们将深入探讨这个概念,以及如何在实际编程中应用。 “点菜”可以被视为生产过程,而“吃菜”则是消费过程。在...

    课程设计之生产者与消费者 java语言编写

    在IT领域,生产者与消费者问题是一个经典的多线程同步问题,主要涉及到计算机科学中的并发编程。本课程设计旨在通过Java语言来实现这一概念,帮助学生深入理解线程间的协作和资源管理。以下是对该主题的详细阐述: ...

Global site tag (gtag.js) - Google Analytics