//生产
package test_produce;
public class Produce implements Runnable{
Stack_used su;
public Produce(){}
public Produce(Stack_used su){
this.su = su;
}
//这里以生产100次为例
public void run(){
for(int i = 0; i < 100; i++){
su.pushOne(i);
}
}
}
//消费
package test_produce;
public class Consume implements Runnable{
Stack_used su;
public Consume(){}
public Consume(Stack_used su){
this.su = su;
}
public void run(){
for(int i = 0; i < 100; i++){
su.popOne();
}
}
}
//栈实现
package test_produce;
import java.util.Stack;
public class Stack_used {
public static final int SIZE = 5;//定义生产上限
Stack<Integer> stack ;
public Stack_used(){
super();
}
public Stack_used(Stack<Integer> stack){
this();
this.stack = stack;
}
public void pushOne(int n){
synchronized(this){
if(stack.size() >= Stack_used.SIZE){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Produce:"+stack.push(n));
//小睡一会,使结果明显一点
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyAll();
}
}
public void popOne(){
synchronized(this){
if(stack.isEmpty()){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("--Consume:"+stack.pop());
//小睡一会,使结果明显一点
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyAll();
}
}
}
//测试
package test_produce;
import java.util.Stack;
public class Test {
public static void main(String[] args) {
Stack_used su = new Stack_used(new Stack<Integer>());
Produce produce = new Produce(su);
Consume consume = new Consume(su);
new Thread(produce).start();
new Thread(consume).start();
}
}
/*
//部分结果...
Produce:0
Produce:1
Produce:2
Produce:3
Produce:4
--Consume:4
Produce:5
--Consume:5
--Consume:3
--Consume:2
--Consume:1
--Consume:0
Produce:6
Produce:7
Produce:8
Produce:9
--Consume:9
--Consume:8
--Consume:7
Produce:10
Produce:11
Produce:12
Produce:13
--Consume:13
--Consume:12
--Consume:11
--Consume:10
Produce:14
Produce:15
Produce:16
Produce:17
--Consume:17
--Consume:16
--Consume:15
--Consume:14
--Consume:6
Produce:18
Produce:19
--Consume:19
--Consume:18
...
*/
分享到:
相关推荐
生产者消费者模式是一种经典的多线程同步问题解决方案,它源于现实世界中的生产流水线,用于描述生产者(Producer)和消费者(Consumer)之间的协作关系。在这个模式中,生产者负责生成产品并放入仓库,而消费者则从...
本示例中的“生产者-消费者”模型是一种经典的多线程问题,它模拟了实际生产环境中的资源分配与消耗过程。下面我们将详细探讨如何在Java中实现这个模型。 首先,我们要理解生产者-消费者模型的基本概念。在这个模型...
本主题将深入探讨“线程实现生产者消费者”模型,以及与之相关的Linux线程(pthread)机制。 首先,我们要理解Linux线程的创建。在Linux中,线程的创建通常通过POSIX线程库(pthread)来实现,其中`pthread_create...
Java中的消费者生产者模式是一种经典的多线程设计模式,它用于解决两个或多个线程间的协同工作问题。在这个模式中,生产者线程负责创建资源,而消费者线程则负责消费这些资源。为了保证线程安全和有效协作,通常会...
在 Java 中,我们可以使用多线程编程和同步机制来实现生产者-消费者模型。 生产者-消费者模型的定义 生产者-消费者模型是一种同步机制,用于解决多线程之间的数据共享和访问问题。生产者负责生产数据,并将其存储...
`BlockingQueue`自动处理了线程同步和阻塞,简化了生产者消费者问题的解决。 ```java BlockingQueue<Integer> queue = new LinkedBlockingQueue(); // 生产者 while (true) { queue.put(produce()); } // 消费者 ...
这个简单的消费者-生产者模式展示了如何利用Java的线程和同步机制来实现线程间的协作。在实际应用中,可能还需要考虑更多的因素,如异常处理、线程中断以及更复杂的同步策略,例如使用`BlockingQueue`接口等。
JAVA生产者消费者线程同步代码学习示例 JAVA生产者消费者线程同步代码学习示例主要介绍了JAVA线程同步的代码学习示例,大家参考使用吧。该示例中,主要解决了生产者消费者问题,该问题是一个典型的线程同步问题。 ...
通过模拟实际生产者和消费者的关系,学生将学习如何创建和管理线程,实现线程间的协作与竞争,以及如何利用Java的同步机制(如synchronized关键字,wait()和notify()方法)来解决生产者-消费者问题。\n\n二、课程...
示例代码展示了一个简单的多线程程序,其中包含了生产者线程和消费者线程的创建过程。具体来说: 1. **生产者线程** (`producer` 函数): 当线程ID为偶数时创建。此线程仅打印出一条消息“`MyThreadfirst`”,然后...
在操作系统中,"生产者消费者问题"是一个经典的多线程同步问题,常被用于理解进程间的协作和同步机制。这个问题由Dijkstra提出,主要探讨如何在共享缓冲区有限的情况下,确保生产者能有效地生产数据,而消费者能及时...
在这个例子中,我们看到的是一个经典的生产者/消费者模型的实现,该模型展示了如何通过线程间的协作来共享资源。 生产者/消费者模型的核心是消息队列,这里用MsgQueue.java类表示。MsgQueue类维护了一个固定大小的...
该系统特别关注了生产者消费者问题,这是一个经典的多线程同步问题,用于演示如何在多线程环境中协调不同线程之间的数据访问。 ### 二、关键技术 #### 1. DOS环境 - **TC 2.0**:一个用于DOS操作系统的C语言编译器...
生产者和消费者线程都将与这个同步栈进行交互。 在实际的代码中,`synchronized`关键字可以用来标记方法或代码块,确保同一时间只有一个线程可以执行。另外,`wait()`和`notify()`方法是Object类提供的,它们可以...
此外,还可以使用其他的同步机制,如条件变量(Condition Variables),来协调生产者和消费者的动作,例如,当缓冲区为空时,消费者线程可以等待条件变量的信号,而生产者线程则在生产产品后发送这个信号。...
生产者线程需要在写入消息前获取互斥锁,以确保在写入期间没有其他线程同时访问。 2. **消费者线程**:从应用消息队列中读取消息并进行处理。同样,消费者线程在读取时也需要先获得互斥锁,防止数据不一致。 3. **...
在多线程编程中,双端队列常用于实现生产者消费者模型的缓冲区,限制了存储元素的数量。Java的LinkedBlockingDeque类是一个线程安全的双端队列,适用于构建高效的并发系统。 七、守护线程(Daemon Thread) 守护...
下面我们将深入探讨Java多线程的核心概念、同步机制、死锁问题以及wait/notify机制,以"生产者与消费者"的例子来具体阐述。 首先,了解Java中的线程。线程是操作系统分配CPU时间的基本单位,每个线程都有自己的程序...
在广工的操作系统实现报告中,主要涵盖了四个关键领域的实践:银行家算法、动态内存分配、生产者消费者问题以及进程调度。这些都是操作系统理论与实践的重要组成部分。 1. **银行家算法**:这是解决资源分配安全性...