`
kuyuyingzi
  • 浏览: 54438 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

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

 
阅读更多

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

条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。

这里的条件和普通意义上的条件表达式有着天壤之别。

条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。

条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法，这样的处理不够精细。

而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。

条件变量比较抽象，原因是他不是自然语言中的条件概念，而是程序控制的一种手段。

下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱：

有一个账户，多个用户（线程）在同时操作这个账户，有的存款有的取款，存款随便存，取款有限制，不能透支，任何试图透支的操作都将等待里面有足够存款才执行操作。

复制代码
package cn.thread;

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;

/**
 * 多线程-条件变量
 * 
 * @author 林计钦
 * @version 1.0 2013-7-26 下午02:43:07
 */
public class ThreadConditionTest {
    public static void main(String[] args) {
        ThreadConditionTest test = new ThreadConditionTest();

        // 创建并发访问的账户
        MyCount myCount = test.new MyCount("95599200901215522", 10000);
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Thread t1 = test.new SaveThread("张三", myCount, 2000);
        Thread t2 = test.new SaveThread("李四", myCount, 3600);
        Thread t3 = test.new DrawThread("王五", myCount, 2700);
        Thread t4 = test.new SaveThread("老张", myCount, 600);
        Thread t5 = test.new DrawThread("老牛", myCount, 1300);
        Thread t6 = test.new DrawThread("胖子", myCount, 800);
        // 执行各个线程
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        // 关闭线程池
        pool.shutdown();
    }

    /**
     * 存款线程类
     */
    public 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);
        }
    }

    /**
     * 取款线程类
     */
    public 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);
        }
    }

    /**
     * 普通银行账户，不可透支
     */
    public 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(); // 释放锁
            }
        }
    }
}
复制代码
张三存款2000，当前余额为12000
王五取款2700，当前余额为9300
老张存款600，当前余额为9900
老牛取款1300，当前余额为8600
胖子取款800，当前余额为7800
李四存款3600，当前余额为11400

假如我们不用锁和条件变量，如何实现此功能呢？下面是实现代码：

复制代码
package cn.thread;

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;

/**
 * 多线程-条件变量
 * 
 * @author 林计钦
 * @version 1.0 2013-7-26 下午02:43:07
 */
public class ThreadConditionTest2 {
    public static void main(String[] args) {
        ThreadConditionTest2 test = new ThreadConditionTest2();

        // 创建并发访问的账户
        MyCount myCount = test.new MyCount("95599200901215522", 10000);
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Thread t1 = test.new SaveThread("张三", myCount, 2000);
        Thread t2 = test.new SaveThread("李四", myCount, 3600);
        Thread t3 = test.new DrawThread("王五", myCount, 2700);
        Thread t4 = test.new SaveThread("老张", myCount, 600);
        Thread t5 = test.new DrawThread("老牛", myCount, 1300);
        Thread t6 = test.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(); // 唤醒所有存款操作
        }
    }

}
复制代码

结合先前同步代码知识，举一反三，将此例改为同步代码块来实现，代码如下：

复制代码
package cn.thread;

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;

/**
 * 多线程-条件变量
 * 
 * @author 林计钦
 * @version 1.0 2013-7-26 下午02:43:07
 */
public class ThreadConditionTest3 {
    public static void main(String[] args) {
        ThreadConditionTest3 test = new ThreadConditionTest3();

        // 创建并发访问的账户
        MyCount myCount = test.new MyCount("95599200901215522", 10000);
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Thread t1 = test.new SaveThread("张三", myCount, 2000);
        Thread t2 = test.new SaveThread("李四", myCount, 3600);
        Thread t3 = test.new DrawThread("王五", myCount, 2700);
        Thread t4 = test.new SaveThread("老张", myCount, 600);
        Thread t5 = test.new DrawThread("老牛", myCount, 1300);
        Thread t6 = test.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) {
                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(); // 唤醒所有存款操作
        }
    }

}
复制代码

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


原文链接：http://www.cnblogs.com/linjiqin/p/3217312.html

分享到：
| Java回调函数实例
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java多线程编程总结

    Java 线程系列博文总结word化，编目如下，欢迎互相学习交流： Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与...Java线程：新特征-条件变量 Java线程：新特征-原子量 Java线程：新特征-障碍器

    java多线程编程总结

    详细的讲述了多线程的各种用法 Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 ...Java线程：新特征-条件变量 Java线程：新特征-原子量 Java线程：新特征-障碍器 Java线程：大总结

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

    一个简单记录java多线程下变量共享问题，分析多线程内部运行

    JAVA多线程并发操作全局变量

    NULL 博文链接：https://toknowme.iteye.com/blog/2212529

    java 多线程 加减变量

    java 多线程 加减变量

    java多线程笔记

    Java线程：线程栈模型与线程的变量 12 Java线程：线程的调度-休眠 13 Java线程：线程的调度-优先级 16 Java线程：线程的调度-让步 19 Java线程：线程的调度-合并 22 Java线程：线程的调度-终止线程 25 Java线程：...

    java ThreadLocal多线程专属的变量源码

    java ThreadLocal多线程专属的变量源码java ThreadLocal多线程专属的变量源码java ThreadLocal多线程专属的变量源码java ThreadLocal多线程专属的变量源码java ThreadLocal多线程专属的变量源码java ThreadLocal多...

    java多线程并发

    java多线程并发的在新窗口

    java线程详解

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

    java多线程通信图解

    java 多线程 其实就是每个线程都拥有自己的内存空间，多线程之间的通信，比例A线程修改了主内存（main方法的线程）变量，需要把A线程修改的结果同步到主线程中，这时B线程再从主线程获取该变量的值，这样就实现了...

    05.多线程编程基础-使用多线程-成员变量与线程安全.mp4

    在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。

    Java多线程与并发库高级应用视频教程22集

    Java多线程与并发库高级应用视频教程22集资源目录：【】01传统线程技术回顾【】02传统定时器技术回顾【】03传统线程互斥技术【】04传统线程同步通信技术【】04传统线程同步通信技术_分割纪录【】05线程范围内共享...

    线程 JAVA java线程 java线程第3版 java线程第2版第3版合集

    本书的新版本展示了如何利用Java线程工具的全部优势，并介绍了JDK 2线程接口中的最新变化。你将学习如何使用线程来提高效率，如何有效地使用它们，以及如何避免常见的错误。本书讨论了死锁、竞态条件以及饥饿等问题...

    java 多线程编程实例

    内容是两个多线程编程的demo: 1.一个线程添加，一个线程减少 2.a线程呼叫b线程，b线程呼叫c线程，c线程呼叫a线程。 能学到： 在学习多线程编程中，我们要把大家用的对象独立出来，然后作为一个 变量传递到各个线程...

    JAVA多线程编程详解-详细操作例子

    多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储...

    Java 多线程编程面试集锦20道问题解答Java多线程编程高难度面试题及解析

    本篇文章提供了20道高难度的Java多线程编程面试题及详细解析，旨在帮助开发者展示出卓越的并发编程能力。在当今高并发的应用场景下，对多线程编程的理解和应用是评估面试者的重要指标。通过这些高难度问题，您将全面...

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