Java线程：新特征-条件变量
 
条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。
 
这里的条件和普通意义上的条件表达式有着天壤之别。
 
条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。
 
条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法，这样的处理不够精细。
 
而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。
 
条件变量比较抽象，原因是他不是自然语言中的条件概念，而是程序控制的一种手段。
 
下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱：
 
有一个账户，多个用户（线程）在同时操作这个账户，有的存款有的取款，存款随便存，取款有限制，不能透支，任何试图透支的操作都将等待里面有足够存款才执行操作。
 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.locks.Condition; 
import java.util.concurrent.locks.Lock; 
import java.util.concurrent.locks.ReentrantLock;

/** 
* Java线程：条件变量 
* 
* @author leizhimin 2009-11-5 10:57:29 
*/ 
public class Test { 
        public static void main(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 extends Thread { 
        private String name;                //操作人 
        private MyCount myCount;        //账户 
        private int x;                            //存款金额

SaveThread(String name, MyCount myCount, int x) { 
                this.name = name; 
                this.myCount = myCount; 
                this.x = x; 
        }

public void run() { 
                myCount.saving(x, name); 
        } 
}

/** 
* 取款线程类 
*/ 
class DrawThread extends Thread { 
        private String name;                //操作人 
        private MyCount myCount;        //账户 
        private int x;                            //存款金额

DrawThread(String name, MyCount myCount, int x) { 
                this.name = name; 
                this.myCount = myCount; 
                this.x = x; 
        }

public void run() { 
                myCount.drawing(x, name); 
        } 
}

/** 
* 普通银行账户，不可透支 
*/ 
class MyCount { 
        private String oid;                         //账号 
        private int cash;                             //账户余额 
        private Lock lock = new ReentrantLock();                //账户锁 
        private Condition _save = lock.newCondition();    //存款条件 
        private Condition _draw = lock.newCondition();    //取款条件

MyCount(String oid, int cash) { 
                this.oid = oid; 
                this.cash = cash; 
        }

/** 
         * 存款 
         * 
         * @param x        操作金额 
         * @param name 操作人 
         */ 
        public void saving(int x, String name) { 
                lock.lock();                        //获取锁 
                if (x > 0) { 
                        cash += x;                    //存款 
                        System.out.println(name + "存款" + x + "，当前余额为" + cash); 
                } 
                _draw.signalAll();            //唤醒所有等待线程。 
                lock.unlock();                    //释放锁 
        }

/** 
         * 取款 
         * 
         * @param x        操作金额 
         * @param name 操作人 
         */ 
        public void drawing(int x, 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();                     //释放锁 
                } 
        } 
}

 
 
李四存款3600，当前余额为13600 
张三存款2000，当前余额为15600 
老张存款600，当前余额为16200 
老牛取款1300，当前余额为14900 
胖子取款800，当前余额为14100 
王五取款2700，当前余额为11400

Process finished with exit code 0

 
假如我们不用锁和条件变量，如何实现此功能呢？下面是实现代码：
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors;

/** 
* Java线程：不用条件变量 
* 
* @author leizhimin 2009-11-5 10:57:29 
*/ 
public class Test { 
        public static void main(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 extends Thread { 
        private String name;                //操作人 
        private MyCount myCount;        //账户 
        private int x;                            //存款金额

SaveThread(String name, MyCount myCount, int x) { 
                this.name = name; 
                this.myCount = myCount; 
                this.x = x; 
        }

public void run() { 
                myCount.saving(x, name); 
        } 
}

/** 
* 取款线程类 
*/ 
class DrawThread extends Thread { 
        private String name;                //操作人 
        private MyCount myCount;        //账户 
        private int x;                            //存款金额

DrawThread(String name, MyCount myCount, int x) { 
                this.name = name; 
                this.myCount = myCount; 
                this.x = x; 
        }

public void run() { 
                myCount.drawing(x, name); 
        } 
}

/** 
* 普通银行账户，不可透支 
*/ 
class MyCount { 
        private String oid;                         //账号 
        private int cash;                             //账户余额

MyCount(String oid, int cash) { 
                this.oid = oid; 
                this.cash = cash; 
        }

/** 
         * 存款 
         * 
         * @param x        操作金额 
         * @param name 操作人 
         */ 
        public synchronized void saving(int x,
String name) { 
                if (x > 0) { 
                        cash += x;                    //存款 
                        System.out.println(name + "存款" + x + "，当前余额为" + cash); 
                } 
                notifyAll();            //唤醒所有等待线程。 
        }

/** 
         * 取款 
         * 
         * @param x        操作金额 
         * @param name 操作人 
         */ 
        public synchronized void drawing(int x,
String name) { 
                if (cash - x < 0) { 
                        try { 
                                wait(); 
                        } catch (InterruptedException e1) { 
                                e1.printStackTrace(); 
                        } 
                } else { 
                        cash -= x;                     //取款 
                        System.out.println(name + "取款" + x + "，当前余额为" + cash); 
                } 
                notifyAll();             //唤醒所有存款操作 
        } 
}

 
输出结果为：
李四存款3600，当前余额为13600 
王五取款2700，当前余额为10900 
老张存款600，当前余额为11500 
老牛取款1300，当前余额为10200 
胖子取款800，当前余额为9400 
张三存款2000，当前余额为11400

Process finished with exit code 0

 
结合先前同步代码知识，举一反三，将此例改为同步代码块来实现，代码如下：
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors;

/** 
* Java线程：改为同步代码块 
* 
* @author leizhimin 2009-11-5 10:57:29 
*/ 
public class Test { 
        public static void main(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 extends Thread { 
        private String name;                //操作人 
        private MyCount myCount;        //账户 
        private int x;                            //存款金额

SaveThread(String name, MyCount myCount, int x) { 
                this.name = name; 
                this.myCount = myCount; 
                this.x = x; 
        }

public void run() { 
                myCount.saving(x, name); 
        } 
}

/** 
* 取款线程类 
*/ 
class DrawThread extends Thread { 
        private String name;                //操作人 
        private MyCount myCount;        //账户 
        private int x;                            //存款金额

DrawThread(String name, MyCount myCount, int x) { 
                this.name = name; 
                this.myCount = myCount; 
                this.x = x; 
        }

public void run() { 
                myCount.drawing(x, name); 
        } 
}

/** 
* 普通银行账户，不可透支 
*/ 
class MyCount { 
        private String oid;                         //账号 
        private int cash;                             //账户余额

MyCount(String oid, int cash) { 
                this.oid = oid; 
                this.cash = cash; 
        }

/** 
         * 存款 
         * 
         * @param x        操作金额 
         * @param name 操作人 
         */ 
        public void saving(int x, String name) { 
                if (x > 0) { 
                        synchronized (this) { 
                                cash += x;                    //存款 
                                System.out.println(name + "存款" + x + "，当前余额为" + cash); 
                                notifyAll();            //唤醒所有等待线程。 
                        } 
                } 
        }

/** 
         * 取款 
         * 
         * @param x        操作金额 
         * @param name 操作人 
         */ 
        public synchronized void drawing(int x,
String name) { 
                synchronized (this) { 
                        if (cash - x < 0) { 
                                try { 
                                        wait(); 
                                } catch (InterruptedException e1) { 
                                        e1.printStackTrace(); 
                                } 
                        } else { 
                                cash -= x;                     //取款 
                                System.out.println(name + "取款" + x + "，当前余额为" + cash); 
                        } 
                } 
                notifyAll();             //唤醒所有存款操作 
        } 
}

 
李四存款3600，当前余额为13600 
王五取款2700，当前余额为10900 
老张存款600，当前余额为11500 
老牛取款1300，当前余额为10200 
胖子取款800，当前余额为9400 
张三存款2000，当前余额为11400

Process finished with exit code 0

 
对比以上三种方式，从控制角度上讲，第一种最灵活，第二种代码最简单，第三种容易犯错。
 

(转)Java线程：新特征-条件变量的更多相关文章

  1. Java线程新特征——Java并发库

    一.线程池   Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定 ...

  2. Java多线程-新特征-阻塞队列ArrayBlockingQueue

    阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度的队列,如果队列满了,添加新元素 ...

  3. Linux线程同步：条件变量

    条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足,它常和互斥锁一起使用.使用时,条件变量被用来阻塞一个线程,当条件不满足时,线程往往解开相应的互斥锁并等待条件发生变化.一旦其它 ...

  4. 线程同步，条件变量pthread_cond_wait

    与互斥锁不同,条件变量是用来等待而不是用来上锁的.条件变量用来自动阻塞一个线程,直到某特殊情况发生为止.条件变量使我们可以睡眠等待某种条件出现.条件变量是利用线程间共享的全局变量进行同步的一种机制,主 ...

  5. （转）java线程安全问题之静态变量、实例变量、局部变量

    java多线程编程中,存在很多线程安全问题,至于什么是线程安全呢,给出一个通俗易懂的概念还是蛮难的,如同<java并发编程实践>中所说: 写道 给线程安全下定义比较困难.存在很多种定义,如 ...

  6. java线程安全问题之静态变量、实例变量、局部变量

    java多线程编程中,存在很多线程安全问题,至于什么是线程安全呢,给出一个通俗易懂的概念还是蛮难的,如同<java并发编程实践>中所说: 写道 给线程安全下定义比较困难.存在很多种定义,如 ...

  7. java多线程技术之条件变量

    上一篇讲述了并发包下的Lock,Lock可以更好的解决线程同步问题,使之更面向对象,并且ReadWriteLock在处理同步时更强大,那么同样,线程间仅仅互斥是不够的,还需要通信,本篇的内容是基于上篇 ...

  8. [b0034] python 归纳 (十九)_线程同步_条件变量

    代码: # -*- coding: utf-8 -*- """ 学习线程同步,使用条件变量 逻辑: 生产消费者模型 一个有3个大小的产品库,一个生产者负责生产,一个消费者 ...

  9. linux线程同步(2)-条件变量

    一.概述                                                    上一篇,介绍了互斥量.条件变量与互斥量不同,互斥量是防止多线程同时访问共享的互斥变量来保 ...

随机推荐

  1. Dojo初探之5:dojo的request（请求）操作、请求过程事件绑定和隐藏数据data()操作（基于dojo1.11.2版本）

    前言: 上一章详细阐述了dojo的事件绑定操作,本章将讲解dojo的请求操作 注:dojo的请求操作与js和jquery完全不同! 1.dojo的请求 dojo通过request.get()/.put ...

  2. php面向对象1

    类和对象的关系 首先看一段代码 var_dump()后的结果 注意 一个对象系统自动分配一个对象标识符!

  3. [codeforces167B]Wizards and Huge Prize

    B. Wizards and Huge Prize time limit per test: 2 seconds memory limit per test: 256 megabytes input: ...

  4. 初学unslider

    1.关于unslider下载 官方提供的下载页面是http://www.bootcss.com/p/unslider/,但总是进不了下载页面,所以我就查看主页的源码,找到unslider.min.js ...

  5. PHP面试题详解

    自己从网上找了几份常考到的PHP面试题进行了整理,然后才有了这份PHP面试题,并且我把所有的题目进行了详细分析和代码分析,希望可以对大家有帮助,谢谢大家. 这份试题我也上传到了百度云,有需要的可以直接 ...

  6. Jenkin-持续集成

    1.Jenkins安装 本文将会介绍如何在windows 中安装Jenkins,并且使用Jenkins进行项目的构建. 首先我们进入到Jenkins 的官网下载地址:https://jenkins.i ...

  7. 【CC2530入门教程-01】IAR集成开发环境的建立与项目开发流程

    [引言] 本系列教程就有关CC2530单片机应用入门基础的实训案例进行分析,主要包括以下6部分的内容:1.CC2530单片机开发入门.2.通用I/O端口的输入和输出.3.外部中断初步应用.4.定时/计 ...

  8. webpack3新特性介绍

    6月20号webpack推出了3.0版本,官方也发布了公告.根据公告介绍,webpack团队将未来版本的改动聚焦在社区提出的功能需求,同时将保持一个快速.稳定的发布节奏.本文主要依据公告内容,简单介绍 ...

  9. 基于jQuery封装的分页组件

    前言: 由于项目需要实现分页效果,上jQuery插件库找了下,但是木有找到自己想要的效果,于是自己封装了个分页组件. 思路: 主要是初始化时基于原型建立的分页模板然后绑定动态事件并实现刷新DOM的分页 ...

  10. DataTable多线程操作报错情况

    最近在写一个http接口时用了DataTable这个强大的利器,接口用浏览器跑起来没任何问题.当时也没考虑并发问题,后来用一个压力测试工具做大并发测试,1000+/s次速度测试.发现程序报错了.程序报 ...