写:取款线程1操作成功,操作金额为-4000,当前金额为6000
写:取款线程2操作成功,操作金额为-8000,当前金额为-2000写:存款线程1操作成功,操作金额为6000,当前金额为4000
读:查询正在查询MyCount{oid='95599200901215522', cash=4000}账户,,当前金额为4000
写:存款线程2操作成功,操作金额为800,当前金额为4800
在实际开发中,最好在能用读写锁的情况下使用读写锁,而不要用普通锁,以求更好的性能。
四、信号量
Java的信号量实际上是一个功能完毕的计数器,对控制一定资源的消费与回收有着很重要的意义,信号量常常用于多线程的代码中,并能监控有多少数目的线程等待获取资源,并且通过信号量可以得知可用资源的数目等等,这里总是在强调“数目”二字,但不能指出来有哪些在等待,哪些资源可用。
因此,本人认为,这个信号量类如果能返回数目,还能知道哪些对象在等待,哪些资源可使用,就非常完美了,仅仅拿到这些概括性的数字,对精确控制意义不是很大。目前还没想到更好的用法。
下面是一个简单的例子:
packageMultiThread;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Semaphore;
/*** Java线程:信号量
*
*
*/
public classTest {
public static voidmain(String[] args) {
MyPool myPool = new MyPool(20);
//创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
MyThread t1 = new MyThread("任务A", myPool, 3);
MyThread t2 = new MyThread("任务B", myPool, 12);
MyThread t3 = new MyThread("任务C", myPool, 7);
//在线程池中执行任务
threadPool.execute(t1);
threadPool.execute(t2);
threadPool.execute(t3);
//关闭池
threadPool.shutdown();
}
}
/*** 一个池
*/
classMyPool {
private Semaphore sp; //池相关的信号量
/*** 池的大小,这个大小会传递给信号量
*
* @paramsize 池的大小
*/MyPool(intsize) {
this.sp = newSemaphore(size);
}
publicSemaphore getSp() {
returnsp;
}
public voidsetSp(Semaphore sp) {
this.sp =sp;
}
}
class MyThread extendsThread {
private String threadName; //线程的名称
private MyPool pool; //自定义池
private int x; //申请信号量的大小
MyThread(String threadName, MyPool pool, intx) {
this.threadName =threadName;
this.pool =pool;
this.x =x;
}
public voidrun() {
try{
//从此信号量获取给定数目的许可
pool.getSp().acquire(x);
//todo:也许这里可以做更复杂的业务
System.out.println(threadName + "成功获取了" + x + "个许可!");
} catch(InterruptedException e) {
e.printStackTrace();
} finally{
//释放给定数目的许可,将其返回到信号量。
pool.getSp().release(x);
System.out.println(threadName + "释放了" + x + "个许可!");
}
}
}
运行结果:
任务A成功获取了3个许可!
任务B成功获取了12个许可!
任务B释放了12个许可!
任务C成功获取了7个许可!
任务A释放了3个许可!
任务C释放了7个许可!
从结果可以看出,信号量仅仅是对池资源进行监控,但不保证线程的安全,因此,在使用时候,应该自己控制线程的安全访问池资源。
五、阻塞队列
阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度的队列,如果队列满了,添加新元素的操作会被阻塞等待,直到有空位为止。同样,当队列为空时候,请求队列元素的操作同样会阻塞等待,直到有可用元素为止。
有了这样的功能,就为多线程的排队等候的模型实现开辟了便捷通道,非常有用。
java.util.concurrent.BlockingQueue继承了java.util.Queue接口,可以参看API文档。
下面给出一个简单应用的例子:
packageMultiThread;
importjava.util.concurrent.BlockingQueue;
importjava.util.concurrent.ArrayBlockingQueue;
/*** Java线程:并发库-阻塞队列
*
*
*/
public classTest {
public static void main(String[] args) throwsInterruptedException {
BlockingQueue bqueue = new ArrayBlockingQueue(20);
for (int i = 0; i < 30; i++) {
//将指定元素添加到此队列中,如果没有可用空间,将一直等待(如果有必要)。
bqueue.put(i);
System.out.println("向阻塞队列中添加了元素:" +i);
}
System.out.println("程序到此运行结束,即将退出----");
}
}
运行结果:
由于阻塞队列的大小为20个,当超过这个数目,又没有元素出队列的时候,队列将会阻塞。到后来的某一个时刻,程序将阻塞队列中的元素出队列,后面的元素才可以进队列。
六、阻塞栈
对于阻塞栈,与阻塞队列相似。不同点在于栈是“后入先出”的结构,每次操作的是栈顶,而队列是“先进先出”的结构,每次操作的是队列头。
这里要特别说明一点的是,阻塞栈是Java6的新特征。、
Java为阻塞栈定义了接口:java.util.concurrent.BlockingDeque,其实现类也比较多,具体可以查看JavaAPI文档。
下面看一个简单例子:
packageMultiThread;
importjava.util.concurrent.BlockingDeque;
importjava.util.concurrent.LinkedBlockingDeque;
classHelloWorldThread {
/*** Java线程:并发库-阻塞栈
*
*
*/
public static voidmain(String[] args) {
BlockingDeque bstack=new LinkedBlockingDeque(20) ;
for(int i=0;i<30;i++){
//将指定元素添加到阻塞栈中,如果没有可用空间,将一直等待(如果有必要)。
bstack.push(i);
System.out.println("向阻塞栈中添加了元素:" +i);
if(bstack.size()==20){
System.out.println("队列满,弹出"+bstack.pop());
System.out.println("队列满,弹出"+bstack.pop());
System.out.println("队列满,弹出"+bstack.pop());
}
}
System.out.println("程序到此运行结束,即将退出----");
}
}
程序的运行结果和阻塞队列的运行结果一样,程序并没结束,二是阻塞住了,原因是栈已经满了,后面追加元素的操作都被阻塞了。
七、条件变量
条件变量是Java5线程中很重要的一个概念,顾名思义,条件变量就是表示条件的一种变量。但是必须说明,这里的条件是没有实际含义的,仅仅是个标记而已,并且条件的含义往往通过代码来赋予其含义。这里的条件和普通意义上的条件表达式有着天壤之别。条件变量都实现了java.util.concurrent.locks.Condition接口,条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的,这样,条件就和一个锁对象绑定起来了。因此,Java中的条件变量只能和锁配合使用,来控制并发程序访问竞争资源的安全。
条件变量的出现是为了更精细控制线程等待与唤醒,在Java5之前,线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法,这样的处理不够精细。而在Java5中,一个锁可以有多个条件,每个条件上可以有多个线程等待,通过调用await()方法,可以让线程在该条件下等待。当调用signalAll()方法,又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。
条件变量比较抽象,原因是他不是自然语言中的条件概念,而是程序控制的一种手段。
下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱:
有一个账户,多个用户(线程)在同时操作这个账户,有的存款有的取款,存款随便存,取款有限制,不能透支,任何试图透支的操作都将等待里面有足够存款才执行操作。
packageMultiThread;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.locks.Condition;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/*** Java线程:条件变量
*
* @authorleizhimin 2009-11-5 10:57:29
*/
public classTest {
public static voidmain(String[] args) {
//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
Thread t1 = new SaveThread("张三", myCount, 2000);
Thread t2 = new SaveThread("李四", myCount, 3600);
Thread t3 = new DrawThread("王五", myCount, 2700);
Thread t4 = new SaveThread("老张", myCount, 600);
Thread t5 = new DrawThread("老牛", myCount, 1300);
Thread t6 = new DrawThread("胖子", myCount, 800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
/*** 存款线程类
*/
class SaveThread extendsThread {
private String name; //操作人
private MyCount myCount; //账户
private int x; //存款金额
SaveThread(String name, MyCount myCount, intx) {
this.name =name;
this.myCount =myCount;
this.x =x;
}
public voidrun() {
myCount.saving(x, name);
}
}
/*** 取款线程类
*/
class DrawThread extendsThread {
private String name; //操作人
private MyCount myCount; //账户
private int x; //存款金额
DrawThread(String name, MyCount myCount, intx) {
this.name =name;
this.myCount =myCount;
this.x =x;
}
public voidrun() {
myCount.drawing(x, name);
}
}
/*** 普通银行账户,不可透支
*/
classMyCount {
private String oid; //账号
private int cash; //账户余额
private Lock lock = new ReentrantLock(); //账户锁
private Condition _save = lock.newCondition(); //存款条件
private Condition _draw = lock.newCondition(); //取款条件
MyCount(String oid, intcash) {
this.oid =oid;
this.cash =cash;
}
/*** 存款
*
* @paramx 操作金额
* @paramname 操作人
*/
public void saving(intx, String name) {
lock.lock(); //获取锁
if (x > 0) {
cash += x; //存款
System.out.println(name + "存款" + x + ",当前余额为" +cash);
}
_draw.signalAll(); //唤醒所有取款等待线程
lock.unlock(); //释放锁
}
/*** 取款
*
* @paramx 操作金额
* @paramname 操作人
*/
public void drawing(intx, String name) {
lock.lock(); //获取锁
try{
if (cash - x < 0) {
_draw.await(); //阻塞取款操作
} else{
cash -= x; //取款
System.out.println(name + "取款" + x + ",当前余额为" +cash);
}
_save.signalAll(); //唤醒所有存款操作线程
} catch(InterruptedException e) {
e.printStackTrace();
} finally{
lock.unlock(); //释放锁
}
}
}
当然,除了使用并发库来实现存取款操作,我们也可以使用synchronized的方法、synchronized的代码块来实现。对比并发库、synchronized方法、synchronized代码块,第一种最灵活,第二种代码最简单,第三种容易犯错。
八、原子量
所谓的原子量即操作变量的操作是“原子的”,该操作不可再分,因此是线程安全的。为何要使用原子变量呢,原因是多个线程对单个变量操作也会引起一些问题。在Java5之前,可以通过volatile、synchronized关键字来解决并发访问的安全问题,但这样太麻烦。Java5之后,专门提供了用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atomic,其中的类也很简单。
下面给出一个反面例子(切勿模仿):
packageMultiThread;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.atomic.AtomicLong;
/*** Java线程:新特征-原子量
*
*
*/
public classTest {
public static voidmain(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
Runnable t1 = new MyRunnable("张三", 2000);
Runnable t2 = new MyRunnable("李四", 3600);
Runnable t3 = new MyRunnable("王五", 2700);
Runnable t4 = new MyRunnable("老张", 600);
Runnable t5 = new MyRunnable("老牛", 1300);
Runnable t6 = new MyRunnable("胖子", 800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
class MyRunnable implementsRunnable {
private static AtomicLong aLong = new AtomicLong(10000); //原子量,每个线程都可以自由操作
private String name; //操作人
private int x; //操作数额
MyRunnable(String name, intx) {
this.name =name;
this.x =x;
}
public voidrun() {
System.out.println(name + "执行了" + x + ",当前余额:" +aLong.addAndGet(x));
}
}
运行结果一:
李四执行了3600,当前余额:13600张三执行了2000,当前余额:15600老张执行了600,当前余额:18900老牛执行了1300,当前余额:20200胖子执行了800,当前余额:21000王五执行了2700,当前余额:18300
运行结果二:
张三执行了2000,当前余额:12000王五执行了2700,当前余额:14700老张执行了600,当前余额:15300老牛执行了1300,当前余额:16600胖子执行了800,当前余额:17400李四执行了3600,当前余额:21000
运行结果三:
张三执行了2000,当前余额:12000王五执行了2700,当前余额:18300老张执行了600,当前余额:18900老牛执行了1300,当前余额:20200胖子执行了800,当前余额:21000李四执行了3600,当前余额:15600
从运行结果可以看出,虽然使用了原子量,但是程序并发访问还是有问题,那究竟问题出在哪里了?
这里要注意的一点是,原子量虽然可以保证单个变量在某一个操作过程的安全,但无法保证你整个代码块,或者整个程序的安全性。因此,通常还应该使用锁等同步机制来控制整个程序的安全性。
下面是对上述代码的修正:
packageMultiThread;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.atomic.AtomicLong;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/*** Java线程:并发库-原子量
*
*
*/
public classTest {
public static voidmain(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
Lock lock=newReentrantLock();
Runnable t1 = new MyRunnable("张三", 2000,lock);
Runnable t2 = new MyRunnable("李四", 3600,lock);
Runnable t3 = new MyRunnable("王五", 2700,lock);
Runnable t4 = new MyRunnable("老张", 600,lock);
Runnable t5 = new MyRunnable("老牛", 1300,lock);
Runnable t6 = new MyRunnable("胖子", 800,lock);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
class MyRunnable implementsRunnable {
private static AtomicLong aLong = new AtomicLong(10000); //原子量,每个线程都可以自由操作
private String name; //操作人
private int x; //操作数额
privateLock lock;
MyRunnable(String name, intx,Lock lock) {
this.name =name;
this.x =x;
this.lock=lock;
}
public voidrun() {
lock.lock();
System.out.println(name + "执行了" + x + ",当前余额:" +aLong.addAndGet(x));
lock.unlock();
}
}
运行结果:
张三执行了2000,当前余额:12000李四执行了3600,当前余额:15600王五执行了2700,当前余额:18300老张执行了600,当前余额:18900老牛执行了1300,当前余额:20200胖子执行了800,当前余额:21000
这里使用了一个对象锁,来控制对并发代码的访问。不管运行多少次,执行次序如何,最终余额均为21000,这个结果是正确的。
有关原子量的用法很简单,关键是对原子量的认识,原子仅仅是保证变量操作的原子性,但整个程序还需要考虑线程安全的。
九、障碍器
Java5中,添加了障碍器类,为了适应一种新的设计需求,比如一个大型的任务,常常需要分配好多子任务去执行,只有当所有子任务都执行完成时候,才能执行主任务,这时候,就可以选择障碍器了。障碍器是多线程并发控制的一种手段,用法很简单。
下面给个例子:
packageMultiThread;
importjava.util.concurrent.BrokenBarrierException;
importjava.util.concurrent.CyclicBarrier;
/*** Java线程:新特征-障碍器
*
*
*/
public classTest {
public static voidmain(String[] args) {
//创建障碍器,并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable)
CyclicBarrier cb = new CyclicBarrier(7, newMainTask());
new SubTask("A", cb).start();
new SubTask("B", cb).start();
new SubTask("C", cb).start();
new SubTask("D", cb).start();
new SubTask("E", cb).start();
new SubTask("F", cb).start();
new SubTask("G", cb).start();
}
}
/*** 主任务
*/
class MainTask implementsRunnable {
public voidrun() {
System.out.println(">>>>主任务执行了!<<<
}
}
/*** 子任务
*/
class SubTask extendsThread {
privateString name;
privateCyclicBarrier cb;
SubTask(String name, CyclicBarrier cb) {
this.name =name;
this.cb =cb;
}
public voidrun() {
System.out.println("[子任务" + name + "]开始执行了!");
for (int i = 0; i < 999999; i++) ; //模拟耗时的任务
System.out.println("[子任务" + name + "]开始执行完成了,并通知障碍器已经完成!");
try{
//通知障碍器已经完成,让出锁(并使得,跳跃的障碍数目-1)
cb.await();
} catch(InterruptedException e) {
e.printStackTrace();
} catch(BrokenBarrierException e) {
e.printStackTrace();
}
}
}
运行结果:
[子任务B]开始执行了!
[子任务E]开始执行了!
[子任务C]开始执行了!
[子任务D]开始执行了!
[子任务A]开始执行了!
[子任务E]开始执行完成了,并通知障碍器已经完成!
[子任务B]开始执行完成了,并通知障碍器已经完成!
[子任务A]开始执行完成了,并通知障碍器已经完成!
[子任务C]开始执行完成了,并通知障碍器已经完成!
[子任务D]开始执行完成了,并通知障碍器已经完成!
[子任务F]开始执行了!
[子任务F]开始执行完成了,并通知障碍器已经完成!
[子任务G]开始执行了!
[子任务G]开始执行完成了,并通知障碍器已经完成!
>>>>主任务执行了!<<<<
从执行结果可以看出,所有子任务完成的时候,主任务执行了,达到了控制的目标