服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - java 中多线程生产者消费者问题详细介绍

java 中多线程生产者消费者问题详细介绍

2021-01-05 11:16CC小观 Java教程

这篇文章主要介绍了java 中多线程生产者消费者问题详细介绍的相关资料,希望通过本文能帮助到大家,需要的朋友可以参考下

java 中多线程生产者消费者问题

前言:

一般面试喜欢问些线程的问题,较基础的问题无非就是死锁,生产者消费者问题,线程同步等等,在前面的文章有写过死锁,这里就说下多生产多消费的问题了

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import java.util.concurrent.locks.*;
 
class BoundedBuffer {
  final Lock lock = new ReentrantLock();//对象锁
  final Condition notFull = lock.newCondition(); //生产者监视器
  final Condition notEmpty = lock.newCondition(); //消费者监视器
 
  //资源对象
  final Object[] items = new Object[10];
  //putptr生产者角标,takeptr消费者角标,count计数器(容器的实际长度)
  int putptr, takeptr, count;
 
  public void put(Object x) throws InterruptedException {
    //生产者拿到锁
   lock.lock();
   try {
     //当实际长度不满足容器的长度
    while (count == items.length)
      //生产者等待
     notFull.await();
    //把生产者产生对象加入容器
    items[putptr] = x;
    System.out.println(Thread.currentThread().getName()+"   put-----------"+count);
    Thread.sleep(1000);
    //如果容器的实际长==容器的长,生产者角标置为0
    if (++putptr == items.length) putptr = 0;
    ++count;
    //唤醒消费者
    notEmpty.signal();
   } finally {
     //释放锁
    lock.unlock();
   }
  }
 
  public Object take() throws InterruptedException {
   lock.lock();
   try {
    while (count == 0)
      //消费者等待
     notEmpty.await();
    Object x = items[takeptr];
    System.out.println(Thread.currentThread().getName()+"   get-----------"+count);
    Thread.sleep(1000);
    if (++takeptr == items.length) takeptr = 0;
    --count;
    //唤醒生产者
    notFull.signal();
    return x;
   } finally {
     //释放锁
    lock.unlock();
   }
  }
 }
 
class Consu implements Runnable{
  BoundedBuffer bbuf;
 
  public Consu(BoundedBuffer bbuf) {
    super();
    this.bbuf = bbuf;
  }
 
  @Override
  public void run() {
    while(true){
    try {
      bbuf.take() ;
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    }
  }
 
}
class Produ implements Runnable{
  BoundedBuffer bbuf;
  int i=0;
  public Produ(BoundedBuffer bbuf) {
    super();
    this.bbuf = bbuf;
  }
 
  @Override
  public void run() {
    while(true){
      try {
        bbuf.put(new String(""+i++)) ;
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
 
}
 
 
 
//主方法
class Lock1{
  public static void main(String[] args) {
    BoundedBuffer bbuf=new BoundedBuffer();
    Consu c=new Consu(bbuf);
    Produ p=new Produ(bbuf);
    Thread t1=new Thread(p);
    Thread t2=new Thread(c);
    t1.start();
    t2.start();
    Thread t3=new Thread(p);
    Thread t4=new Thread(c);
    t3.start();
    t4.start();
  }
}

这个是jdk版本1.5以上的多线程的消费者生产者问题,其中优化的地方是把synchronized关键字进行了步骤拆分,对对象的监视器进行了拆离,synchronized同步,隐式的建立1个监听,而这种可以建立多种监听,而且唤醒也优化了,之前如果是synchronized方式,notifyAll(),在只需要唤醒消费者或者只唤醒生产者的时候,这个notifyAll()将会唤醒所有的冻结的线程,造成资源浪费,而这里只唤醒对立方的线程。代码的解释说明,全部在源码中,可以直接拷贝使用。

如有疑问请留言或者到本站社区交流讨论,希望通过本文能帮助到大家,谢谢大家对本站的支持!

原文链接:http://blog.csdn.net/qq_37347341/article/details/77751226

延伸 · 阅读

精彩推荐