【线程同步2】java实现生产者消费者问题$扩展，出现的问题，思考

最新推荐文章于 2024-09-09 10:13:20 发布
最新推荐文章于 2024-09-09 10:13:20 发布
阅读量640 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/robert_lizhiqiang/article/details/39319771
版权

继文章：

【线程同步】java实现生产者消费者问题与线程中的wait与notify总结 - robert_lizhiqiang的专栏 - 博客频道 - CSDN.NET
http://blog.csdn.net/robert_lizhiqiang/article/details/39292271

之后，总结了两个方法的使用，于是把P—C模式又编写了一次，这次编写，没有使用extends Thread 的方式，而是实现了Runnable接口。并且两个类并没有在Main的内部类

里面。

刚写版本一的如下：

package tmppkg;

import java.util.LinkedList;

public class MyProducerConsumer2 {
	private static LinkedList<Object> storeHouse = new LinkedList<Object>();
	public static final int MAX = 10;

	public static void main(String[] args) {

		new MyProducerConsumer2().start();
	}

	private void start() {

		Producer producer = new Producer();
		Consumer consumer = new Consumer();
		Thread producerThread = new Thread(producer, "producer");
		Thread consumerThread = new Thread(consumer, "consumer");
		producerThread.start();
		consumerThread.start();
		

	}

	class Producer extends Thread {

		public void run() {
				// TODO Auto-generated method stub
				synchronized (storeHouse) {
					try {
						while (storeHouse.size() > MyProducerConsumer2.MAX) {
							System.out
									.println("the storeHouse's size are full, please wait...");

							storeHouse.wait();

						}
						boolean isAddOk = storeHouse.add(new Object());
						if (isAddOk) {
							System.out
									.println(Producer.class
											+ " add a new object to the store house, please eat it...");
							Thread.sleep((long) Math.random() * 3000);
							storeHouse.notify();

						}
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						System.out
								.println("the storeHouse's size are full, and it is be interrupted!");
					}

				}

		}

	}

	class Consumer extends Thread {

		public void run() {

				// TODO Auto-generated method stub
				synchronized (storeHouse) {
					try {
						while (storeHouse.size() == 0) {
							System.out
									.println("there is no object in store house, I'm hungry...");
							storeHouse.wait();
						}
						storeHouse.removeLast();
						System.out
								.println(Consumer.class
										+ " eat a object from store house, please add one...");
						Thread.sleep((long) Math.random() * 3000);
						storeHouse.notify();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

				}

		}

	}
}

运行结果： 

class tmppkg.MyProducerConsumer2$Producer add a new object to the store house, please eat it...
class tmppkg.MyProducerConsumer2$Consumer eat a object from store house, please add one...

百思不得其解，为什么就运行了两行不进行下去了，一直以为是C类出现的问题

后来和标准的一对比，知道了，少了while(true)

原来同步的意义在于此！！！

（刚无意发现，按ESC可以全屏编写）

于是改进如下：

但是发现运行后，速度超级快，跟本不是慢慢的一个一个来。应该是Thread.sleep中的时间问题

果然，应该写成：

Thread.sleep((long) (Math.random() * 3000))

而不是

Thread.sleep((long) Math.random() * 3000)

有趣的是，我把C改成了正确的，P没改，就出现了if（full）的情况，这样当然算正确了，因为在10以内都的正确。

如下：

import java.util.LinkedList;

public class MyProducerConsumer {
	public static LinkedList<Object> storeHouse = new LinkedList<Object>();
	public static final int MAX = 10;

	public static void main(String[] args) {

		new MyProducerConsumer().start();
	}

	private void start() {
		Producer producer = new Producer();
		Consumer consumer = new Consumer();
		Thread producerThread = new Thread(producer, "producer");
		Thread consumerThread = new Thread(consumer, "consumer");
		producerThread.start();
		consumerThread.start();
	}

}

class Producer implements Runnable {

	public void run() {
		while (true) {

			// TODO Auto-generated method stub
			synchronized (MyProducerConsumer.storeHouse) {
				while (MyProducerConsumer.storeHouse.size() >= MyProducerConsumer.MAX) {
					System.out
							.println("the storeHouse's size are full, please wait...");
					try {
						MyProducerConsumer.storeHouse.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						System.out
								.println("the storeHouse's size are full, and it is be interrupted!");
					}
				}
				boolean isAddOk = MyProducerConsumer.storeHouse
						.add(new Object());
				if (isAddOk) {
					System.out
							.println(Producer.class
									+ " add a new object to the store house, please eat it...");
					try {
						Thread.sleep((long) Math.random() * 3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						System.out.println(Producer.class
								+ " sleep failed! please check it out....");
					}
					MyProducerConsumer.storeHouse.notify();

				}
			}

		}
	}

}

/*
 * synchronized (obj) { while (<condition does not hold>) obj.wait(); ... //
 * Perform action appropriate to condition }
 */
class Consumer implements Runnable {

	public void run() {
		while (true) {

			// TODO Auto-generated method stub
			synchronized (MyProducerConsumer.storeHouse) {
				try {
					while (MyProducerConsumer.storeHouse.size() == 0) {
						System.out
								.println("there is no object in store house, I'm hungry...");
						MyProducerConsumer.storeHouse.wait();
					}
					MyProducerConsumer.storeHouse.removeLast();
					System.out
							.println(Consumer.class
									+ " eat a object from store house, please add one...");
					// Thread.sleep((long) Math.random() * 3000);
					Thread.sleep((long) (Math.random() * 3000));

					MyProducerConsumer.storeHouse.notify();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}

		}
	}

}

运行结果如下（刚开始出现了11个是因为在代码 
MyProducerConsumer.storeHouse.size() >= MyProducerConsumer.MAX
中写成了>，后来加上=就正常了）： 

class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
class Producer add a new object to the store house, please eat it...
the storeHouse's size are full, please wait...
class Consumer eat a object from store house, please add one...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
class Producer add a new object to the store house, please eat it...
class Consumer eat a object from store house, please add one...
至此，明白了：

1、同步其实是在加了syn关键字后，才算同步。

2、对于同步不结束的线程，加上了while(true)才算真正意义上的P-C模式。

3、其它一些小问题，例如sleep的问题，要改正。

4、其实对于同步来说，不管是extends Thread方式，还是实现Runnable接口的方式，结果都是一样的，只要按照API来写就正常。当然我更prefer实现接口。

5、对于同步来说，内部类和外部类并没有关系。

6、对于同步来说，同步的obj（在本例中是storeHouse）是否是成员变量，和是否是静态变量，没有关系。


题外话：


对于启动线程，是否启动了一种线程还是启动了多线程，得益于某网友一个错误的博客：

java多线程总结 - Rollen Holt - 博客园
http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html

中的一段：

引用如下————————————————————————————————————————————————————————————————————————————————————————————————————————

关于选择继承Thread还是实现Runnable接口？

其实Thread也是实现Runnable接口的：

1
2
3
4
5
6
7
8
class  Thread implements  Runnable {
     //…
public  void  run() {
         if  (target != null ) {
              target.run();
         }
         }
}

其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html

Thread和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
  * @author Rollen-Holt 继承Thread类，不能资源共享
  * */
class  hello extends  Thread {
     public  void  run() {
         for  ( int  i = 0 ; i < 7 ; i++) {
             if  (count > 0 ) {
                 System.out.println( "count= "  + count--);
             }
         }
     }
 
     public  static  void  main(String[] args) {
         hello h1 = new  hello();
         hello h2 = new  hello();
         hello h3 = new  hello();
         h1.start();
         h2.start();
         h3.start();
     }
 
     private  int  count = 5 ;
}

 

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。

我们换为Runnable接口

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class  MyThread implements  Runnable{
 
     private  int  ticket = 5 ;  //5张票
 
     public  void  run() {
         for  ( int  i= 0 ; i<= 20 ; i++) {
             if  ( this .ticket > 0 ) {
                 System.out.println(Thread.currentThread().getName()+ "正在卖票" + this .ticket--);
             }
         }
     }
}
public  class  lzwCode {
     
     public  static  void  main(String [] args) {
         MyThread my = new  MyThread();
         new  Thread(my, "1号窗口" ).start();
         new  Thread(my, "2号窗口" ).start();
         new  Thread(my, "3号窗口" ).start();
     }
}

 

　　

 

 

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1

 

总结一下吧：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

 

所以，本人建议大家劲量实现接口。

引用结束————————————————————————————————————————————————————————————————————————————————————————————————————————

这段他是错误的。

总结1也是错误的。

解释如下：

class hello extends Thread {
public void run() {
for (int i = 0; i < 7; i++) {
if (count > 0) {
System.out.println("count= " + count--);
}
}
}

public static void main(String[] args) {
helloh1 = new hello();
helloh2 = new hello();
helloh3 = new hello();
h1.start();
h2.start();
h3.start();
}

private int count = 5;
}
这个继承Thread实现的方法，在main方法中其实是创建了是三个线程，所以运行的时候输出的是15条记录。但是如下实例：

private int ticket = 5; //5张票

public void run() {
for (int i=0; i<=20; i++) {
if (this.ticket > 0) {
System.out.println(Thread.currentThread().getName()+ "正在卖票"+this.ticket--);
}
}
}
}
public class lzwCode {

public static void main(String [] args) {
MyThreadmy = new MyThread();
new Thread(my, "1号窗口").start();
new Thread(my, "2号窗口").start();
new Thread(my, "3号窗口").start();
}
}
这个是通过实现Runnable接口实现资源共享中，只是创建了一个线程。

题外话结束

不止鱼
关注
Java线程同步与通信案例——生产者消费者问题
qq_39382032的博客
08-15 286
目录概述生产者与消费者模型实现代码 概述 生产者消费者问题是一个计算机领域的经典案例，计算机专业的同学在学习操作系统这门课时，一定会对此有所了解。下面就使用Java提供的多线程来实现这个案例。主要涉及到了线程间同步与线程间通信。 目前所学的创建多线程的常用方法包括：继承Thread类、实现Runnable接口（后续还有其他实现多线程的方法） 实现线程同步的常用方法包括：同步代码块、同步方法、锁Lock 实现线程间通信的常用方法包括：waiting()、notify()、notifyAll() 生产者与消费者
Java---生产者与消费者模式
chenfang0529的博客
07-29 1594
在Java语言中，实现生产者消费者问题时，可以采用三种方式： - 使用 Object 的 wait/notify 的消息通知机制； - 使用 Lock 的 Condition 的 await/signal 的消息通知机制； - 使用 BlockingQueue 实现。
12.多线程的实现方式、线程安全问题的产生与解决以及生产者与消费者问题
zhaozhiwei314的博客
07-10 214
一、实现多线程 1.1 了解多线程 多线程是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，从而提升性能。 1.2 并发与并行 并行是指同一时刻，有多个指令在多个CPU上同时执行。 并发是指同一时刻，有多个指令在单个CPU上交替执行。 1.3 进程和线程 **进程：**是指正在运行的程序，比如说360杀毒软件这个程序 **独立性：**进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。 **动态性：**进程的实质是程序的一
黑马程序员——java第十一、十二天：多线程（创建线程1-2、多线程同步代码、实现Runnable接口、安全死锁）
xintuyuyu的专栏
08-31 948
------- android培训、java培训、期待与您交流！ ----------  多线程概述 一个进程中至少有一个线程。 进程：是一个正在执行的程序。                    每个进程执行都有一个执行的顺序，该顺序是一个执行路径或叫一个控制单元。 线程：就是进程中的一个独立的控制单元，线程控制着进程的执行。                    一个进程中至少
经典的进程同步问题-----生产者-消费者问题详解
热门推荐
丹丹的后花园
11-25 1万+
经典的进程同步问题-----生产者-消费者问题详解 ​ 本文和接下来几篇博文是对上篇文章（进程同步机制）的一次实践，通过具体的例子来加深理论的理解，会用三个经典的进程同步问题来进行讲解，并且会配有伪代码和Java实践（使用多线程模拟），深入的进行讲解。 ​ 进程同步问题是一个非常重要且相当有趣的问题，因而吸引了很多学者对他进行研究，比如在前几篇博客中提到的老熟人迪杰斯特拉，由此也产生了一系列经典的...
一篇文章带你搞定高性能的生产者-消费者模式：无锁的实现
南淮北安的博客
01-21 2194
用BlockigQueue队列实现生产者和消费者是一个不错的选择。它可以很自然地实现作为生产者和消费者的内存缓冲区。但是BlockigQueue队列并不是一个高性能的实现，它完全使用锁和阻塞等待来实现线程间的同步。在高并发场合，它的性能并不是特别的优越。就像之前我已经提过的：ConcurrentLinkedQueue是一个高性能的队列，但是BlockingQueue队列只是为了方便数据共享。 而ConcurrentLinkedQueue队列的秘诀就在于大量使用了无锁的CAS操作。同理，如果我们使用CAS来实
详解多线程死锁&lock锁&生产者消费者问题
weixin_51787261的博客
01-07 1959
死锁 定义 多个线程各自占有一些公共资源，并且互相等待其它线程占有的的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情况，某一个同步块同时拥有“两个以上对象的锁”，就可能发生死锁问题。 ...
C++ 生产者-消费者模式详细解析与代码实现
shuai_258的博客
09-09 3046
生产者-消费者模式是一种通过缓冲区将生产者和消费者解耦的设计模式。生产者线程负责生成数据，而消费者线程负责消费数据。由于生产者和消费者的工作速度可能不同，因此缓冲区的存在使得它们可以独立运行。生产者-消费者模式是一种常见且有效的并发编程模型。在C++中，通过std::mutex和，我们可以轻松实现这一模式来协调多线程间的工作。本篇博客详细介绍了该模式的工作原理，并通过代码示例展示了它的实现。希望对你理解并应用生产者-消费者模式有所帮助。
操作系统经典问题--生产者消费者问题
2301_79659699的博客
07-18 2395
生产者消费者问题在并发编程和系统设计中有广泛的应用场景，包括日志处理、任务队列、缓存更新、消息队列和实时数据处理等。这些场景都涉及到数据的生成和处理，以及需要平衡不同组件之间的速度和效率。通过应用生产者消费者模式，可以实现数据的解耦、异步处理和并发控制等目标，从而提高系统的可扩展性、可靠性和性能。
java生产者消费者模型
有个疙叫瘩儿的博客
12-14 4990
前言 生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 基于synchronized配合wait()和notify()方法的实现 这也是最简单最基础的实现，缓冲区满和为空时都调用wait()方法等待，当生产者生产了一个产品或者消费者消费了一个产品之后会唤醒所有线程。 public class Test...
浅谈java线程中生产者与消费者的问题
09-02
- **阻塞队列**：在实际开发中，Java的`java.util.concurrent`包提供了阻塞队列（如`BlockingQueue`），它内置了线程同步机制，可以更方便地解决生产者与消费者问题，简化代码。 - **信号量**：`Semaphore`类可以...
java实现生产者消费者
10-18
在Java编程中，"生产者消费者"模式是一种典型的多线程问题解决模型，它通过共享资源来协调生产者和消费者之间的操作。这个模式的核心在于如何有效地管理资源的生产和消费，以避免生产过快导致资源浪费，或者消费者...
Java多线程Queue、BlockingQueue和使用BlockingQueue实现生产消费者模型方法解析
08-28
总的来说，`Java`的`BlockingQueue`是实现并发和多线程间数据共享的有效工具，它通过阻塞机制提供了高效且线程安全的通信途径，尤其在处理生产者-消费者问题时，大大简化了编程复杂性。了解并熟练掌握`BlockingQueue...
用多线程同步方法解决生产者－消费者问题
03-07
总的来说，解决生产者-消费者问题需要深入理解线程同步原理，并结合具体的需求进行设计和实现。这个过程不仅锻炼了编程能力，也对并发编程的理解有着重要的实践意义。在实际项目中，这样的并发控制技术广泛应用在...
X3手薄试用的工程之星3.0
10-27
X3手薄试用的工程之星3.0
传感器+绘制.alp
10-27
Android andlua androlua lua实战工程
基于聚类和分通道场景识别（CAD&CG）
10-27
基于聚类和分通道场景识别（CAD&CG）
yolo算法-水底垃圾检测数据集-1121张图像带标签-宏观塑料detection-dpdol.zip
最新发布
10-27
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 标签格式（也可转成voc格式）：<class> <x_center> <y_center> <width> <height> 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
活动回调.alp
10-27
Android andlua androlua lua实战工程
Java多线程：生产者消费者问题详解与解决方案
总结，解决Java多线程中的生产者与消费者问题，关键在于理解线程同步和通信机制，如何利用`wait()`和`notify()`来确保并发操作的正确性和顺序。在实际编程中，合理设计类结构，利用同步代码块或synchronized方法来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不止鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值