java多线程-消费者和生产者模式

简介: /* * 多线程-消费者和生产者模式 * 在实现消费者生产者模式的时候必须要具备两个前提,一是,必须访问的是一个共享资源,二是必须要有线程锁,且锁的是同一个对象 * */ 1 /*资源类中定义了name(名字):用来区分消费者还是生产者 2 * 定义了flag标记:用来...

/*
* 多线程-消费者和生产者模式
* 在实现消费者生产者模式的时候必须要具备两个前提,一是,必须访问的是一个共享资源,二是必须要有线程锁,且锁的是同一个对象
* */

 1 /*资源类中定义了name(名字):用来区分消费者还是生产者
 2  *         定义了flag标记:用来区分有没有货物(默认生产一个就要消费一个)
 3  *         定义了count(生产的个数统计)
 4  *     set方法:用来生产商品
 5  *     out方法:用来消费商品*/
 6 class TestSource{
 7     private String name=null;
 8     private boolean flag=false;
 9     private int count=0;
10     /*先通过flag标记判断有没有商品,有商品则等待,没有则生产商品,唤醒所有程序,并将flag标记改变*/
11     public synchronized void set(String name){
12         //判断是否有产品,这里用while循环,避免在多个生产者同时生产时,会出现生产多个产品,却只消费一个
13         while(flag){
14             try {
15                 wait();
16             } catch (InterruptedException e) {
17                 e.printStackTrace();
18             }
19         }
20         //生产产品并输出
21         this.name=name+"编号"+count++;
22         System.out.println("生产"+name+"++");
23         //改变标记
24         flag=true;
25         //唤醒所有的线程
26         notifyAll();
27     }
28     public synchronized void out(){
29         while(!flag){
30             try {
31                 wait();
32             } catch (InterruptedException e) {
33                 e.printStackTrace();
34             }
35         }
36         System.out.println("消费"+name+"---");
37         flag=false;
38         notifyAll();
39     }
40 }
41 class Product implements Runnable{
42     private TestSource ts=null;
43     //初始化线程里用到的资源
44     public Product(TestSource ts){
45         this.ts=ts;
46     }
47     //重写线程里run方法
48     public void run() {
49         while(true){
50             ts.set("生产产品");
51         }
52     }
53 }
54 class Customer implements Runnable{
55     private TestSource ts=null;
56     public Customer(TestSource ts){
57         this.ts=ts;
58     }
59     public void run() {
60         while(true){
61             ts.out();
62         }
63     }
64 }
65 public class test {
66     public static void main(String[] args) {
67         //初始化唯一的资源
68         TestSource ts=new TestSource();
69         //创建生产者和消费者两个对象,并传入两者共同操作的唯一资源
70         Customer cu=new Customer(ts);
71         Product pr=new Product(ts);
72         //将对象传入线程对象
73         Thread t1=new Thread(cu);
74         Thread t2=new Thread(pr);
75         Thread t3=new Thread(cu);
76         Thread t4=new Thread(pr);
77         //开启线程
78         t1.start();
79         t2.start();
80         t3.start();
81         t4.start();
82     }
83 }

 

/*在java1.5版本以后,用lock和unlick代替了synchronized关键字
* 用await()代替了wait()方法
* 用signal()代替了notify()
* 这里的signal可以指定唤醒莫一类的线程,而不是像notifyAll,必须全部唤醒

这里我们对上面的代码进行一定的改写*/

 1 class TestSource{
 2     private String name=null;
 3     private boolean flag=false;
 4     private int count=0;
 5     //定义lock,用来代替synchronized关键字
 6     private Lock lock=new ReentrantLock();
 7     private Condition condition_pro=lock.newCondition();
 8     private Condition condition_con=lock.newCondition();
 9     public void set(String name){
10         //对代码段进行上锁
11         lock.lock();
12         try {
13             while(flag){
14                 try {
15                     //wait();
16                     //调用生产者控制方法
17                     condition_pro.await();
18                 } catch (InterruptedException e) {
19                     e.printStackTrace();
20                 }
21             }
22             this.name=name+"编号"+count++;
23             System.out.println("生产"+name+"++");
24             flag=true;
25             //notifyAll();
26             //唤醒消费者线程
27             condition_con.signal();
28         } finally{
29             //解锁,让其他进程进入访问
30             lock.unlock();
31         }
32         
33         
34     }
35     public void out(){
36         lock.lock();
37         try{
38             while(!flag){
39                 try {
40                     //wait();
41                     condition_con.await();
42                 } catch (InterruptedException e) {
43                     e.printStackTrace();
44                 }
45             }
46             System.out.println("消费"+name+"---");
47             flag=false;
48             //notifyAll();
49             condition_pro.signal();
50         }finally{
51             lock.unlock();
52         }
53         
54     }
55 }

 

相关文章
|
9天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
4天前
|
监控 Java 开发者
深入理解Java中的线程池实现原理及其性能优化####
本文旨在揭示Java中线程池的核心工作机制,通过剖析其背后的设计思想与实现细节,为读者提供一份详尽的线程池性能优化指南。不同于传统的技术教程,本文将采用一种互动式探索的方式,带领大家从理论到实践,逐步揭开线程池高效管理线程资源的奥秘。无论你是Java并发编程的初学者,还是寻求性能调优技巧的资深开发者,都能在本文中找到有价值的内容。 ####
|
9天前
|
缓存 Java 开发者
Java多线程并发编程:同步机制与实践应用
本文深入探讨Java多线程中的同步机制,分析了多线程并发带来的数据不一致等问题,详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用,结合代码示例展示了如何有效解决竞态条件,提升程序性能与稳定性。
|
9天前
|
安全 Java 开发者
Java中的多线程编程:从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧,旨在帮助读者理解多线程的工作原理,掌握线程的创建、管理和同步机制。通过具体示例和最佳实践,本文展示了如何在Java应用中有效地利用多线程技术,提高程序性能和响应速度。
37 1
|
消息中间件 Java Kafka
Java实现Kafka生产者和消费者的示例
Kafka是由Apache软件基金会开发的一个开源流处理平台,由Scala和Java编写。Kafka的目标是为处理实时数据提供一个统一、高吞吐、低延迟的平台。
408 0
Java实现Kafka生产者和消费者的示例
|
消息中间件 Java Kafka
Java实现Kafka生产者与消费者
Java实现Kafka生产者与消费者
712 0
|
18天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
|
26天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
17天前
|
安全 Java 开发者
Java 多线程并发控制:深入理解与实战应用
《Java多线程并发控制:深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧,适合Java开发者深入学习和实践参考。
|
17天前
|
Java 开发者
Java多线程编程的艺术与实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档,本文以实战为导向,通过生动的实例和详尽的代码解析,引领读者领略多线程编程的魅力,掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者,本文都将为你打开多线程编程的新视角。 ####