`

Java线程：新特征-条件变量

    博客分类：
  • java
Java多线程thread 
阅读更多

条件变量是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多线程的问题
评论
发表评论

文章已被作者锁定，不允许评论。

相关推荐

    Java多线程编程总结

    Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 ...Java线程：新特征-条件变量 Java线程：新特征-原子量 Java线程：新特征-障碍器 Java线程：大总结

    java线程详解

    Java线程：新特征-条件变量 Java线程：新特征-原子量 Java线程：新特征-障碍器 Java线程：深入ThreadLocal 一、标准例子 二、不用ThreadLocal 三、自己实现个ThreadLocal 四、透过现象看本质 Java线程：大...

    Java多线程

    #### 十九、Java线程：新特征-条件变量 条件变量允许线程等待某个条件成立后再继续执行，是实现高级同步控制的重要工具。 #### 二十、Java线程：新特征-原子量 原子量提供了一种无需锁即可进行原子更新的方式，...

    Java多线程运算集合

    #### 十五、Java线程：新特征-条件变量 - **条件变量**： - 条件变量是 `java.util.concurrent.locks.Condition` 类提供的高级同步机制。 - 它提供了更加灵活的线程等待和唤醒机制，比传统的 `wait()` 和 `notify...

    Java线程入门大全

    ### Java线程入门大全知识点详解 #### 一、线程基础概述 - **定义与特点：** - **线程**是一种比进程更细粒度的执行单元，它允许在一个进程中并发执行多个任务。 - **多线程**能够提高程序的效率和响应速度，...

    Java线程：volatile关键字

    Java 线程 volatile 关键字详解 Java™ 语言包含两种内在的同步机制：同步块（或方法）和 volatile...volatile 变量是一种轻量级的同步机制，可以用于提供线程安全，但是需要满足一定的条件，并且不能用于所有的情况。

    图灵图书：图解JAVA多线程设计模式

    ### 图灵图书：图解JAVA多线程设计模式 #### 关键知识点概览 - **Java多线程基础** - 线程的概念与创建方式 - 线程的状态及其转换 - 线程生命周期 - **Java并发编程** - 同步机制（synchronized关键字） - ...

    java多线程_java多线程下变量共享_

    在Java中，线程共享变量可以通过两种方式实现：静态成员变量和实例成员变量。静态成员属于类，所有该类的实例都可以访问，因此在多线程环境下默认共享；实例成员变量则属于对象，每个线程都有自己独立的副本，除非...

    Java并发编程面试题（2024最新版）-重点.docx

    - 创建一个新的进程比创建一个新的线程消耗更多的资源和时间。 - 进程之间的通信需要通过IPC机制，而线程之间的通信可以直接访问共享数据。 **5. 上下文切换：** - 定义：当CPU从一个线程切换到另一个线程时，会...

    Java线程pdf ---培训内部资料

    ### Java线程培训内部资料深度解析 #### 一、线程基本概念 线程作为并发执行的基本单位，是操作系统为了实现资源的有效利用和任务的高效处理而设计的一种机制。在Java中，线程是一个轻量级的过程，它可以独立于...

    CoreJava考试试题---达内科技.pdf

    - `for`循环是Java中常用的循环结构之一，用于重复执行一段代码直到满足某个条件为止。 - 循环初始化、条件判断和循环后的操作都应在`for`语句中明确指定，而不能在循环体外部进行。 ### 5. do-while循环的执行...

    各公司Java面试题汇总

    Java变量及运算符 - **n、x、y 的含义：** - `n` 通常代表一个数值（Number）。 - `x` 可能代表某个状态或标志。 - `y` 在示例中被赋予特定值，用于表示不同的条件或状态。 - **赋值与计算：** - 示例中提到...

    java常见面试题---线程篇

    以下是一些关于Java线程的常见面试知识点，这些内容可能出现在线程.doc文档中： 1. **线程的创建方式**： - 实现`Runnable`接口：创建一个类实现`Runnable`接口，并重写`run()`方法，然后将实例传递给`Thread`类的...

    java基础教程----精华版

    - **变量**：在Java中，变量是存储数据的容器，分为基本类型（如int, double, boolean等）和引用类型（如类、接口、数组）。 - **数据类型**：Java有两大类数据类型，即原始类型（primitives）和引用类型...

Magicbox
Global site tag (gtag.js) - Google Analytics