Java多线程详解5【面试+工作】

Java多线程详解【面试+工作】

Java线程:新特征-信号量

Java的信号量实际上是一个功能完毕的计数器,对控制一定资源的消费与回收有着很重要的意义,信号量常常用于多线程的代码中,并能监控有多少数目的线程等待获取资源,并且通过信号量可以得知可用资源的数目等等,这里总是在强调“数目”二字,但不能指出来有哪些在等待,哪些资源可用。

因此,本人认为,这个信号量类如果能返回数目,还能知道哪些对象在等待,哪些资源可使用,就非常完美了,仅仅拿到这些概括性的数字,对精确控制意义不是很大。目前还没想到更好的用法。

下面是一个简单例子:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/** 
* Java线程:新特征-信号量
* 
* @author leizhimin 2009-11-5 13:44:45 
*/ 
publicclass Test {
 publicstaticvoid main(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(); 
        } 
} 

/** 
* 一个池 
*/ 
class MyPool { 
 private Semaphore sp;    //池相关的信号量

 /** 
         * 池的大小,这个大小会传递给信号量
         * 
         * @param size 池的大小
         */ 
        MyPool(int size) {
 this.sp =new Semaphore(size);
        } 

 public Semaphore getSp() {
 return sp;
        } 

 publicvoid setSp(Semaphore sp) {
 this.sp = sp;
        } 
} 

class MyThread extends Thread { 
 private String threadname;            //线程的名称
 private MyPool pool;                        //自定义池
 privateint x;                                    //申请信号量的大小

        MyThread(String threadname, MyPool pool, int x) {
 this.threadname = threadname;
 this.pool = pool;
 this.x = x;
        } 

 publicvoid run() {
 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 +"个许可!");
                } 
        } 
}
任务B成功获取了12个许可!
任务B释放了12个许可!
任务A成功获取了3个许可!
任务C成功获取了7个许可!
任务C释放了7个许可!
任务A释放了3个许可!

Process finished with exit code 0

从结果可以看出,信号量仅仅是对池资源进行监控,但不保证线程的安全,因此,在使用时候,应该自己控制线程的安全访问池资源。

Java线程:新特征-阻塞队列

阻塞队列是Java5线程新特征中的内容,Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue,阻塞队列的概念是,一个指定长度的队列,如果队列满了,添加新元素的操作会被阻塞等待,直到有空位为止。同样,当队列为空时候,请求队列元素的操作同样会阻塞等待,直到有可用元素为止。

有了这样的功能,就为多线程的排队等候的模型实现开辟了便捷通道,非常有用。

java.util.concurrent.BlockingQueue继承了java.util.Queue接口,可以参看API文档。

下面给出一个简单应用的例子:
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

/** 
* Java线程:新特征-阻塞队列
* 
* @author leizhimin 2009-11-5 14:59:15 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args)throws InterruptedException {
                BlockingQueue bqueue = new ArrayBlockingQueue(20);
 for (int i = 0; i < 30; i++) {
 //将指定元素添加到此队列中,如果没有可用空间,将一直等待(如果有必要)。
                        bqueue.put(i); 
                        System.out.println("向阻塞队列中添加了元素:" + i);
                } 
                System.out.println("程序到此运行结束,即将退出----");
        } 
}
输出结果:
向阻塞队列中添加了元素:0
向阻塞队列中添加了元素:1 
向阻塞队列中添加了元素:2 
向阻塞队列中添加了元素:3 
向阻塞队列中添加了元素:4 
向阻塞队列中添加了元素:5 
向阻塞队列中添加了元素:6 
向阻塞队列中添加了元素:7 
向阻塞队列中添加了元素:8 
向阻塞队列中添加了元素:9 
向阻塞队列中添加了元素:10 
向阻塞队列中添加了元素:11 
向阻塞队列中添加了元素:12 
向阻塞队列中添加了元素:13 
向阻塞队列中添加了元素:14 
向阻塞队列中添加了元素:15 
向阻塞队列中添加了元素:16 
向阻塞队列中添加了元素:17 
向阻塞队列中添加了元素:18 
向阻塞队列中添加了元素:19

可以看出,输出到元素19时候,就一直处于等待状态,因为队列满了,程序阻塞了。

这里没有用多线程来演示,没有这个必要。

另外,阻塞队列还有更多实现类,用来满足各种复杂的需求:ArrayBlockingQueue, DelayQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue,具体的API差别也很小。

Java线程:新特征-阻塞栈

对于阻塞栈,与阻塞队列相似。不同点在于栈是“后入先出”的结构,每次操作的是栈顶,而队列是“先进先出”的结构,每次操作的是队列头。

这里要特别说明一点的是,阻塞栈是Java6的新特征。

Java为阻塞栈定义了接口:java.util.concurrent.BlockingDeque,其实现类也比较多,具体可以查看JavaAPI文档。

下面看一个简单例子:

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

/** 
* Java线程:新特征-阻塞栈
* 
* @author leizhimin 2009-11-5 15:34:29 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args)throws InterruptedException {
                BlockingDeque bDeque = new LinkedBlockingDeque(20);
 for (int i = 0; i < 30; i++) {
 //将指定元素添加到此阻塞栈中,如果没有可用空间,将一直等待(如果有必要)。
                        bDeque.putFirst(i); 
                        System.out.println("向阻塞栈中添加了元素:" + i);
                } 
                System.out.println("程序到此运行结束,即将退出----");
        } 
}
输出结果:
向阻塞栈中添加了元素:0
向阻塞栈中添加了元素:1 
向阻塞栈中添加了元素:2 
向阻塞栈中添加了元素:3 
向阻塞栈中添加了元素:4 
向阻塞栈中添加了元素:5 
向阻塞栈中添加了元素:6 
向阻塞栈中添加了元素:7 
向阻塞栈中添加了元素:8 
向阻塞栈中添加了元素:9 
向阻塞栈中添加了元素:10 
向阻塞栈中添加了元素:11 
向阻塞栈中添加了元素:12 
向阻塞栈中添加了元素:13 
向阻塞栈中添加了元素:14 
向阻塞栈中添加了元素:15 
向阻塞栈中添加了元素:16 
向阻塞栈中添加了元素:17 
向阻塞栈中添加了元素:18 
向阻塞栈中添加了元素:19

从上面结果可以看到,程序并没结束,二是阻塞住了,原因是栈已经满了,后面追加元素的操作都被阻塞了。

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 
*/ 
publicclass Test {
 publicstaticvoid 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 SaveThreadextends Thread {
 private String name;                //操作人
 private MyCount myCount;        //账户
 privateint x;                            //存款金额

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

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

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

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

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


/** 
* 普通银行账户,不可透支 
*/ 
class MyCount { 
 private String oid;                        //账号
 privateint 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 操作人
         */ 
 publicvoid 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 操作人
         */ 
 publicvoid 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 
*/ 
publicclass Test {
 publicstaticvoid 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 SaveThreadextends Thread {
 private String name;                //操作人
 private MyCount myCount;        //账户
 privateint x;                            //存款金额

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

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

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

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

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

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

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

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

 /** 
         * 取款 
         * 
         * @param x        操作金额
         * @param name 操作人
         */ 
 publicsynchronizedvoid 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 
*/ 
publicclass Test {
 publicstaticvoid 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 SaveThreadextends Thread {
 private String name;                //操作人
 private MyCount myCount;        //账户
 privateint x;                            //存款金额

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

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

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

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

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

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

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

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

 /** 
         * 取款 
         * 
         * @param x        操作金额
         * @param name 操作人
         */ 
 publicsynchronizedvoid 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帮帮(javahelp)

原文发表时间:2017-12-12

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏青青天空树

趣味题:恺撒Caesar密码(c++实现)

描述:Julius Caesar 生活在充满危险和阴谋的年代。为了生存,他首次发明了密码,用于军队的消息传递。假设你是Caesar 军团中的一名军官,需要把Ca...

8420
来自专栏Pythonista

牛掰的python与unix

  加载subprocess模块仅仅是将可以使用的代码文件加载进来。也可以创建自己的模块或文件,拱以后重复使用,这与加载subprocess模块的方法相同。IP...

11820
来自专栏JadePeng的技术博客

Docker+Jenkins持续集成环境(5): android构建与apk发布

项目组除了常规的java项目,还有不少android项目,如何使用jenkins来实现自动构建呢?本文会介绍安卓项目通过jenkins构建的方法,并设计开发一个...

53380
来自专栏Java开发者杂谈

Netty(1):第一个netty程序

为什么选择Netty   netty是业界最流行的NIO框架之一,它的健壮型,功能,性能,可定制性和可扩展性都是首屈一指的,Hadoop的RPC框架Avro就使...

41770
来自专栏小勇DW3

ThreadPoolExecutor 线程池的源码解析

  上一篇从整体上介绍了Executor接口,从上一篇我们知道了Executor框架的最顶层实现是ThreadPoolExecutor类,Executors工厂...

13950
来自专栏Flutter知识集

Flutter 实践 MVVM

在做Android或iOS开发时,经常会了解到MVC,MVP和MVVM。MVVM在移动端一度被非常推崇,虽然也有不少反对的声音,不过MVVM确实是不错的设计架构...

3.3K50
来自专栏函数式编程语言及工具

Akka(43): Http:SSE-Server Sent Event - 服务端主推消息

   因为我了解Akka-http的主要目的不是为了有关Web-Server的编程,而是想实现一套系统集成的api,所以也需要考虑由服务端主动向客户端发送指令的...

27290
来自专栏潇涧技术专栏

Pury Project Analysis

Pury的源码:https://github.com/NikitaKozlov/Pury

9520
来自专栏FreeBuf

scapy在wlan中的应用

Scapy 又是scapy,这是python的一个网络编程方面的库,它在wlan中也有很强大的应用。一般我们买块网卡,然后aircrack-ng套件爆破一下邻居...

364100
来自专栏JavaEdge

长文慎入-探索Java并发编程与高并发解决方案(更新中)1 基本概念2 CPU3 项目准备4线程安全性5发布对象7 AQS9 线程池10 死锁

50080

扫码关注云+社区

领取腾讯云代金券