java多线程:并发包中的信号量和计数栓的编程模型

一:信号量的编程模型

 1 package com.yeepay.sxf.test.atomic.test;
 2
 3 import java.util.concurrent.Semaphore;
 4
 5 /**
 6  * 测试信号量
 7  * 相当于有一把可以控制并发量的锁。
 8  * 例如银行柜台,只有两个窗口。但三个人做业务,只允许同时有两个人能进行做业务
 9  *
10  * 多线程
11  * @author sxf
12  *
13  */
14 public class TestSemaphore {
15
16     public static void main(String[] args) {
17         //声明两个信号量
18         Semaphore semaphore=new Semaphore(2);
19         //有三个线程抢许可证(信号量)做业务
20         Person person1=new Person("sxf", semaphore);
21         Person person2=new Person("sxs", semaphore);
22         Person person3=new Person("ssy", semaphore);
23         //启动这三个线程工作(同时允许的并发量为2)
24         person1.start();
25         person2.start();
26         person3.start();
27     }
28
29 }
30
31 class Person extends Thread{
32
33     /**
34      * 信号量(许可证)
35      */
36     private Semaphore semaphore;
37     /**
38      * 当前线程的名字
39      */
40     private String cname;
41
42     public Person(String cname,Semaphore semaphore) {
43         this.cname=cname;
44         this.semaphore=semaphore;
45     }
46
47
48     @Override
49     public void run() {
50         System.out.println("Person.run(==>)"+getCname()+" is wating........");
51         try {
52             //获取许可证
53             semaphore.acquire();
54             System.out.println("Person.run()"+getCname()+" is doneing.......");
55             Thread.sleep(3000);
56             System.out.println("Person.run(==>)"+getCname()+"  is service done......");
57             //释放许可证
58             semaphore.release();
59         } catch (InterruptedException e) {
60             e.printStackTrace();
61         }
62     }
63
64
65     public Semaphore getSemaphore() {
66         return semaphore;
67     }
68
69
70     public void setSemaphore(Semaphore semaphore) {
71         this.semaphore = semaphore;
72     }
73
74
75     public String getCname() {
76         return cname;
77     }
78
79
80     public void setCname(String cname) {
81         this.cname = cname;
82     }
83
84
85
86
87
88
89
90
91
92
93 }

View Code

一:计数栓的编程模型

 1 package com.yeepay.sxf.test.atomic.test;
 2
 3 import java.util.concurrent.CountDownLatch;
 4 /**
 5  * 测试记数栓
 6  *
 7  * 当记数栓定义的多个事件发生时候,才能执行任务
 8  * @author sxf
 9  *
10  */
11 public class TestCountDowanLatch {
12
13     public static void main(String[] args) throws InterruptedException {
14         //定义三个事件的计数栓
15         CountDownLatch countDownLatch=new CountDownLatch(3);
16         //定义任务线程
17         Runer runer=new Runer("sxf", countDownLatch);
18         Runer runer2=new Runer("sxs", countDownLatch);
19         Runer runer3=new Runer("sxy", countDownLatch);
20
21         //启动任务线程
22         runer.start();
23         runer2.start();
24         runer3.start();
25
26         //住线程监控特定事件的发生次数
27         for(int i=0;i<3;i++){
28             Thread.sleep(3000);
29             System.out.println("TestCountDowanLatch.main(事件发生第【"+(i+1)+"】次");
30             if(i==2){
31                 System.out.println("TestCountDowanLatch.main(事件发生次数已经达标允许线程执行任务)");
32                 countDownLatch.countDown();
33             }
34
35         }
36
37     }
38 }
39
40
41 class Runer extends Thread{
42     /**
43      * 计数栓
44      */
45     private CountDownLatch countDownLatch;
46
47     private String cname;
48
49     public Runer(String cname,CountDownLatch countDownLatch) {
50         this.cname=cname;
51         this.countDownLatch=countDownLatch;
52     }
53
54     @Override
55     public void run() {
56         try {
57             System.out.println("Runer.run()"+getName()+"  is await.............");
58             countDownLatch.await();
59             System.out.println("Runer.run()"+getName()+"  is doneing...........cname");
60
61         } catch (InterruptedException e) {
62             // TODO Auto-generated catch block
63             e.printStackTrace();
64         }
65     }
66
67     public CountDownLatch getCountDownLatch() {
68         return countDownLatch;
69     }
70
71     public void setCountDownLatch(CountDownLatch countDownLatch) {
72         this.countDownLatch = countDownLatch;
73     }
74
75     public String getCname() {
76         return cname;
77     }
78
79     public void setCname(String cname) {
80         this.cname = cname;
81     }
82
83
84
85 }

View Code

 

时间: 2024-10-10 14:28:46

java多线程:并发包中的信号量和计数栓的编程模型的相关文章

Java多线程同步设计中使用Metux

Mutex是互斥体,广泛地应用在多线程编程中.本文以广为流程的Doug Lea的concurrent工具包的Mutex实现为例,进行一点探讨.在Doug Lea的concurrent工具包中,Mutex实现了Sync接口,该接口是concurrent工具包中所有锁(lock).门(gate)和条件变量(condition)的公共接口,Sync的实现类主要有:Mutex.Semaphore及其子类.Latch.CountDown.ReentrantLock等.这也体现了面向抽象编程的思想,使我们可

java多线程和并发包入门示例_java

一.java多线程基本入门java多线程编程还是比较重要的,在实际业务开发中经常要遇到这个问题. java多线程,传统创建线程的方式有两种. 1.继承自Thread类,覆写run方法. 2.实现Runnable接口,实现run方法. 启动线程的方法都是调用start方法,真正执行调用的是run方法.参考代码如下: 复制代码 代码如下: package com.jack.thread; /** * 线程简单演示例子程序 *  * @author pinefantasy * @since 2013-

详解Java多线程编程中LockSupport类的线程阻塞用法_java

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语. LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程,而且park()和unpark()不会遇到"Thread.suspend 和 Thread.resume所可能引发的死锁"问题. 因为park() 和 unpark()有许可的存在:调用 park() 的线程和另一个试图将其 unpark() 的线程之间的竞争将保持活性. 基本用法LockSupport 很类似于二元信号量

java多线程:jdk并发包的总结(转载)

转载地址:http://blog.csdn.net/yangbutao/article/details/8479520 1.java 高并发包所采用的几个机制(CAS,volatile,抽象队列同步)    CAS(乐观操作),jdk5以前采用synchronized,对共享区域进行同步操作,synchronized是重的操作,在高并发情况下,会引起线程频繁切换:而CAS是一种乐观锁机制,compare and swap,不加锁,而是假设没有冲突去完成,若有冲突会重试(非阻塞).compare&

关于java多线程中的join方法

问题描述 关于java多线程中的join方法 1.主线程可能在子线程结束之前 结束吗?如果可能的话 举一个例子 2.如何理解join方法, 结合实际应用. 非常感谢非常感谢!!! 解决方案 关于join,参考:http://www.blogjava.net/jnbzwm/articles/330549.html 解决方案二: 主线程可能在子线程结束之前 结束吗 一般来说不可以,但是也不一定,如果子线程在执行finally中的代码,应该会等它执行完了才退出. 晕,join方法和什么"让主线程等子线

简介Java多线程在交易中间件测试中的应用

引言 随着信息系统的结构的日益复杂和规模的不断扩大,交易中间件在复杂系统的应用也越来越广.交易中间件 作为一个中间层的系统,在接收客户端请求时,通常需要做一些负载控制和用户缓存的一些功能.对于软件测试人员来说, 测试交易中间件时,避免不了模拟客户端在高负载情况下的一些有规律或随机的行为.这些测试有时是功能性验证测试 (Functional Verification Test),有时也涉及到性能测试 (Performance Test). 本文将介绍如何使用 Java 语言 编写多线程的自动化测试

Java多线程编程中synchronized线程同步的教程_java

0.关于线程同步 (1)为什么需要同步多线程?线程的同步是指让多个运行的线程在一起良好地协作,达到让多线程按要求合理地占用释放资源.我们采用Java中的同步代码块和同步方法达到这样的目的.比如这样的解决多线程无固定序执行的问题: public class TwoThreadTest { public static void main(String[] args) { Thread th1= new MyThread1(); Thread th2= new MyThread2(); th1.sta

详解Java多线程编程中线程的启动、中断或终止操作_java

线程启动: 1.start() 和 run()的区别说明start() : 它的作用是启动一个新线程,新线程会执行相应的run()方法.start()不能被重复调用. run() : run()就和普通的成员方法一样,可以被重复调用.单独调用run()的话,会在当前线程中执行run(),而并不会启动新线程! 下面以代码来进行说明. class MyThread extends Thread{ public void run(){ ... } }; MyThread mythread = new

Java多线程编程中线程锁与读写锁的使用示例_java

线程锁LockLock  相当于 当前对象的 Synchronized import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * Lock lock = new ReentrantLock(); * lock.lock(); lock.unLock(); * 类似于 synchronized,但不能与synchronized 混用 */ public class Lo