Java线程详解(16)-条件变量

最新推荐文章于 2021-02-26 00:15:17 发布
最新推荐文章于 2021-02-26 00:15:17 发布
阅读量290 收藏
点赞数
分类专栏： Java 多线程 thread 文章标签： java 多线程
Java 同时被 3 个专栏收录
518 篇文章 14 订阅
订阅专栏
多线程
55 篇文章 0 订阅
订阅专栏
thread
21 篇文章 0 订阅
订阅专栏

        条件变量是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线程：条件变量 
 */  
public class Test {  
    public static void main(String[] args){  
       //创建并发访问的账户  
       MyCount myCount=new MyCount("6215580000000000000",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();                    //释放锁  
     }  
     //取款  
     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  


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

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
   
/** 
 * Java线程：不用条件变量 
 */  
public class Test {  
    public static void main(String[] args){  
       //创建并发访问的账户  
       MyCount myCount=new MyCount("6215580000000000000",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,Stringname){         
       if (x > 0) {  
           cash += x; // 存款  
           System.out.println(name + "存款" + x + "，当前余额为" + cash);  
       }  
       notifyAll(); //唤醒所有等待线程。  
     }  
     //取款  
     public synchronized void drawing(int x, String name){       
       if (cash - x < 0) {  
           try {  
              wait();  
           } catch (InterruptedException e) {  
              e.printStackTrace();  
           }  
       } else {  
           cash -= x; // 取款  
           System.out.println(name + "取款" + x + "，当前余额为" + cash);  
       }  
       notifyAll(); // 唤醒所有存款操作       
     }  
}  


        执行结果：

张三存款2000，当前余额为12000  
王五取款2700，当前余额为9300  
李四存款3600，当前余额为12900  
老牛取款1300，当前余额为11600  
胖子取款800，当前余额为10800  
老张存款600，当前余额为11400 

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

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
   
/** 
 * Java线程：改用同步代码块 
 */  
public class Test {  
    public static void main(String[] args){  
       //创建并发访问的账户  
       MyCount myCount=new MyCount("6215580000000000000",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(); //唤醒所有等待线程。  
           }  
       }       
     }  
     //取款  
     public synchronized void drawing(int x, String name) {      
     synchronized (this) {  
        if (cash - x < 0) {  
            try {  
               wait();  
            }catch (InterruptedException e) {  
               e.printStackTrace();  
            }  
        } else {  
            cash -= x; // 取款  
            System.out.println(name + "取款" + x + "，当前余额为" + cash);  
        }               
     }  
     notifyAll(); // 唤醒所有存款操作  
     }  
}  


        执行结果：

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


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

zl1zl2zl3
关注
专栏目录
Java并发——条件变量
JustKian的博客
12-25 1222
1.定义 在操作系统——多线程同步互斥一文中已详细介绍过了条件变量及其使用注意事项。条件变量，是为了解决等待同步需求，实现线程间协作通信的一种机制。条件变量用来自动阻塞一个线程，直到某特殊情况发生唤醒该线程为止。通常条件变量和锁机制同时使用。 2.Java中的条件变量 2.1 synchronized + wait()、notify()、notifyAll() 线程A（消费者）: synchron...
java线程本地变量ThreadLocal详解
08-25
Java 线程本地变量 ThreadLocal 详解 ThreadLocal 是 Java 中的一个类，提供了线程安全的对象封装，用于解决多线程访问数据的冲突问题。ThreadLocal 的主要目的是为每个线程提供一个变量副本，从而隔离了多个线程...
Java线程：新特征-条件变量
weixin_33847182的博客
11-05 176
Java线程：新特征-条件变量   条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。   这里的条件和普通意义上的条件表达式有着天壤之别。   条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实...
java 多线程------条件变量
dingxingmei的专栏
08-03 522
代码如下--------------- package dxm.com.test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util
java 条件变量_java Condition条件变量的通俗易懂解释、基本使用及注意点
weixin_33900916的博客
02-16 394
最近在看pthread方面的书，看到条件变量一节的时候，回忆了下java中条件变量的使用方式。java中条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。条...
java Condition条件变量的通俗易懂解释、基本使用及注意点
weixin_34019929的博客
02-11 211
最近在看pthread方面的书，看到条件变量一节的时候，回忆了下java中条件变量的使用方式。 java中条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是理解多任务并发执行的关键。在计算机系统中，进程和线程是两种不同的执行单元。 1. **进程**：每个进程都有独立的内存空间，这意味着不同进程之间的数据不能直接共享。例如，当你打开多...
Java 多线程与并发-Java并发知识体系详解.pdf
07-11
Java并发编程是Java开发中的重要领域，涉及到多线程、并发控制、同步机制等多个知识点。以下是对Java并发知识体系的详细解析。 首先，我们要理解并发的理论基础。并发是为了提高系统资源利用率和处理能力，让多个...
Java多线程详解及示例
最新发布
07-20
Java内存模型（JMM）规定了线程如何访问共享变量，以及如何保证数据一致性。volatile关键字可以确保线程之间的可见性，禁止指令重排序。原子性操作（如AtomicInteger）则可以保证在多线程环境下的原子性。 6. 线程...
JAVA多线程编程详解-详细操作例子.docx
10-24
Java线程有以下四种基本状态： 1. 新状态：线程已创建但尚未调用start()方法。 2. 可执行状态：线程可以运行，但可能不在CPU执行。 3. 运行状态：线程正在CPU上执行。 4. 阻塞状态：线程被阻塞，等待资源或事件。 5....
java 条件变量,什么是java中的条件变量？
weixin_42323064的博客
02-16 175
Q1. What is a condVar in Java? If I see the code below, does a condition variable necessarily have to be within the 'mutex.acquire()' and 'mutex.release()' block?public void put(Object x) throws Inter...
Java 条件变量
Alps__的专栏
03-16 802
条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。 条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对
java 条件变量_关于JAVA Condition 条件变量
weixin_35988038的博客
02-16 536
Condition 条件变量条件变量是线程同步对象中的一种，主要用来等待某种条件的发生，条件发生后，可以唤醒等待在该条件上的一个线程，或所有线程。条件变量要与锁一起协同工作.条件变量调用Lock.newCondition()获得一个实例：ReentrantLock lock = new ReentrantLock();Condition condition =lock.newCondition()...
java线程条件变量_Java线程：条件变量、原子量、线程池等
weixin_35959694的博客
02-26 343
一、条件变量条件变量实现了java.util.concurrent.locks.Condition接口，条件变量的实例化就是通过一个Lock对象上调用newCondition()方法获得的，这样条件就和一个锁绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。条件变量的出现是为了更精细的控制线程等待与唤醒，一个锁可以有多个条件，每个条件上有多个线程等待，通过a...
java 条件变量_什么是Java中的条件变量？
weixin_30676351的博客
02-16 185
Q1。 Java中的condVar是什么？如果我看到下面的代码，条件变量是否一定必须在“ mutex.acquire() ”和“mutex.release() ”块内？public void put(Object x) throws InterruptedException {mutex.acquire();try {while (count == array.length)notFull.awa...
条件变量 java_什么是java中的条件变量？
weixin_33508642的博客
02-19 141
Q1.什么是Java中的condVar？如果我看到下面的代码,条件变量是否必须在’mutex.acquire()’和’mutex.release()’块中？public void put(Object x) throws InterruptedException {mutex.acquire();try {while (count == array.length)notFull.await();a...
java 条件变量Condition——笔记
linux_lihuafeng的专栏
04-04 548
package com.warehorseCondition; public class GetThread implements Runnable{ private WareHorse horse; public GetThread(WareHorse horse) { super(); this.horse = horse; } @Override public v
java 多线程 条件变量_Java多线程:条件变量
weixin_29499957的博客
02-13 129
Java多线程:条件变量条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。这里的条件和普通意义上的条件表达式有着天壤之别。条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用ne...
java 条件变量_深入理解条件变量Condition
weixin_39896617的博客
02-19 436
序可重入锁(ReentrantLock)是 synchronized 关键字的扩展，更加灵活。还有一种ReentrantLock应用场景是和Condition搭配使用，实现多线程环境下等待状态条件的功能。Object.wait 和 Object.notify 是和 synchronized 配合使用的，条件变量Condition.await 和 Condition.signal 是和Reentra...
Java线程详解：run方法与局部变量
"这篇教程主要讨论的是Java编程中关于线程和`run`方法的使用，...总结来说，理解Java线程和`run`方法的使用对于编写并发程序至关重要，这涉及到如何合理地利用系统资源，避免竞态条件，以及保证程序的正确性和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值