JAVA多线程-基础Lock Condition 并发集合

代码的逻辑:

1)SProducer不停的产生number到queue中.
2)3个carrier不停的取出queue中的number.
3)如果queue中存在10个剩余number时,SProducer会停下来等Carrier消费一些后再生产.
4)如果Carrier发现queue中没有number时,会等待.
5)如果Carrier取出的数字末尾为4, 则会挑起罢工事件.
6)Carrier罢工会引发一个Negotiation线程进行谈判.
7)罢工阶段SProducer和所有Carrier均停工.
8)Negotiation如果发现取出的number首位为3或者7,将引发谈判失败.
9)如果谈判成功,则恢复工作,如果谈判失败,则破产,所有线程均退出.

注意:使用lock的时候一定要注意, lock()和unlock()方法一定要成对出现. 最好放到try{}finally{}中,这样,unlock()方法必会调到.倘若没有使用unlock()就return了,会导致线程死锁.

view sourceprint?

001 package concurrency;

002

003 import java.util.ArrayList;

004 import java.util.concurrent.ArrayBlockingQueue;

005 import java.util.concurrent.locks.Condition;

006 import java.util.concurrent.locks.ReentrantLock;

007

008 public class Producer extends Thread {

009 private final static ArrayBlockingQueue<String> numbers = new ArrayBlockingQueue<String>(10);

010 private final static ArrayList<Thread> threads = new ArrayList<Thread>();

011 private volatile boolean negotiating = false;

012 private ReentrantLock negotiationLock = new ReentrantLock();

013 private Condition negotiationCondition = negotiationLock.newCondition();

014

015 private class Negotiation implements Runnable {

016 private String number;

017 private Negotiation(String number) {

018 this.number = number;

019 }

020 public void run() {

021 try {

022 System.out.println("Start negotiation...");

023 sleep(5000);

024 if (number.startsWith("7") || number.startsWith("3")) {

025 System.out.println("Negotiation broken.");

026 for (Thread t : threads) {

027 t.interrupt();

028 }

029 System.out.println("Negotiation broken post handle.");

030 return;

031 }

032 System.out.println("Negotiation succeeds.");

033 } catch (InterruptedException e) {

034 System.out.println("Middle man is killed.");

035 }

036 negotiationLock.lock();

037 negotiating = false;

038 negotiationCondition.signalAll();

039 negotiationLock.unlock();

040 }

041 }

042

043 private class Carrier implements Runnable {

044 private String name;

045 private Carrier(String name) {

046 this.name = name;

047 }

048 public void run() {

049 while(true) {

050 try{

051 negotiationLock.lock();

052 while(negotiating) {

053 try {

054 System.out.println("Carrier ["+name+"] join stricks.");

055 negotiationCondition.await();

056 } catch (InterruptedException e) {

057 System.out.println("Negotiation fails. Carrier [" + name + "] retires.");

058 return;

059 }

060 }

061 } finally {

062 negotiationLock.unlock();

063 }

064 String number;

065 try {

066 number = numbers.take();

067 System.out.println("Carrier [" + name + "] carries "+ number +" out of List;");

068 } catch (InterruptedException e1) {

069 System.out.println("Negotiation fails. Carrier [" + name + "] retires.");

070 return;

071 }

072

073 if (number.endsWith("4")) {

074 try {

075 negotiationLock.lock();

076 while (negotiating) {

077 try {

078 negotiationCondition.await();

079 } catch (InterruptedException e) {

080 System.out.println("Negotiation fails. Carrier [" + name + "] retires.");

081 return;

082 }

083 }

084 negotiating = true;

085 System.out.println("Stricks happen on number:"+number);

086 new Thread(new Negotiation(number)).start();

087 } finally {

088 negotiationLock.unlock();

089 }

090 }

091 }

092 }

093 }

094

095 public void run() {

096 Thread a = new Thread(new Carrier("a"));

097 Thread b = new Thread(new Carrier("b"));

098 Thread c = new Thread(new Carrier("c"));

099 threads.add(this);

100 threads.add(a);

101 threads.add(b);

102 threads.add(c);

103

104 a.start();

105 b.start();

106 c.start();

107

108 this.produceNumbers();

109

110 }

111

112 private void produceNumbers() {

113 while (true) {

114 while(negotiating) {

115 negotiationLock.lock();

116 try {

117 System.out.println("Stricking... Producer waiting for negotiation result.");

118 negotiationCondition.await();

119 System.out.println("Negotiation succeeds. Producer happy.");

120 } catch (InterruptedException e) {

121 System.out.println("Negotiation fails. Producer breaks up.");

122 return;

123 } finally {

124 negotiationLock.unlock();

125 }

126 }

127

128 String number = ""+new java.util.Random().nextInt(47);

129

130 try {

131 numbers.put(number);

132 System.out.println("Produce number " + number + " into List;");

133 } catch (InterruptedException e) {

134 System.out.println("Negotiation fails. Producer breaks up.");

135 return;

136 }

137 }

138 }

139

140

141 public static void main(String[] args) {

142 new Producer().start();

143 }

144 }

转载于:https://www.cnblogs.com/shihao/archive/2012/11/09/2762221.html

JAVA多线程-基础Lock Condition 并发集合相关推荐

lock 线程 java_JAVA多线程-基础Lock Condition 并发集合
跟上一篇文章比较,这次改进了之前的代码,使用了Lock Condition 和并发集合.代码量减了一些,并且更加容易读了. 这篇代码是上一篇的改进版,逻辑在前篇有说明,以防大家看不到,我再重现贴一遍. ...
java多线程基础学习[狂神说java-多线程笔记]
java多线程基础学习一.线程简介 1.类比 2.程序进程线程 3.线程的核心概念二.线程的实现(重点) 调用方法与调用多线程的区别 Thread 类 1.thread使用方法 2. 代码实现 3 ...
Java多线程干货系列（1）：Java多线程基础
转载自 Java多线程干货系列(1):Java多线程基础前言多线程并发编程是Java编程中重要的一块内容,也是面试重点覆盖区域,所以学好多线程并发编程对我们来说极其重要,下面跟我一起开启本次的学 ...
JAVA多线程基础篇-关键字synchronized
1.概述 syncronized是JAVA多线程开发中一个重要的知识点,涉及到多线程开发,多多少少都使用过.那么syncronized底层是如何实现的?为什么加了它就能实现资源串行访问?本文将基于上述 ...
爬梯：Java多线程基础
学习资源:狂神说 Java多线程基础 1.多线程概述 Process 进程一个进程可以有多个线程. Thread 线程线程就是独立的执行路径在程序运行时,即使没有自己创建线程,后台也会有多个线程 ...
Java多线程学习处理高并发问题
在程序的应用程序中,用户或请求的数量达到一定数量,并且无法避免并发请求.由于对接口的每次调用都必须在返回时终止,因此,如果接口的业务相对复杂,则可能会有多个用户.调用接口时,该用户将冻结. 以下内容将 ...
java多线程基础视频_【No996】2020年最新 Java多线程编程核心基础视频课程
01.课程介绍.mp4 02.多线程编程基础-进程与线程.mp4 03.多线程编程基础-使用多线程-继承Thread类.mp4 04.多线程编程基础-使用多线程-实现Runnable接口.mp4 05 ...
Java多线程基础总结
一.线程和进程关系二.创建方式 1.继承Thread类,重写run方法 2.实现Runable接口,重写run方法 3.使用匿名内部类三.API接口 start() currentThread() ...
Java多线程基础知识（一）
Java多线程一.Java线程模型实现线程有三种方式:使用内核线程实现.使用用户线程实现和使用用户线程加轻量级进程混合实现.内核线程是直接由操作系统内核支持的线程,通过内核完成线程切换,内核通过操 ...

JAVA多线程-基础Lock Condition 并发集合

代码的逻辑:

JAVA多线程-基础Lock Condition 并发集合相关推荐

最新文章

热门文章