线程基础:JDK1.5+(8)——线程新特性(上)
来源:互联网 发布:字体软件哪个好 编辑:程序博客网 时间:2024/06/10 07:47
1、概要
如果您阅读JAVA的源代码,出现最多的代码作者包括:Doug Lea、Mark Reinhold、Josh Bloch、Arthur van Hoff、Neal Gafter、Pavani Diwanji等等。其中java.util.concurrent包中出现的基本都是Doug Lea的名字。Doug Lea,是对Java影响力最大的个人,直接贡献的设计包括java的Collections和util.concurrent。
JDK1.5中一个重要特性就是util.concurrent包和其子包(当让JDK1.5中的特性还包括了很多,例如泛型、解包/封包等,但这些不属于我们这个专题讨论的范围)。在这个系列的专题中,我们已经对util.concurrent包中的一些主要功能做了介绍,例如:BlockingQueue、ThreadPoolExecutor、Executors等。这篇文章中,我们对这个包中其他中要的线程特性进行介绍。
2、带返回值的Callable
在之前的文章中,我们提到JAVA线程相关的Runnable接口中的run()方法没有提供返回值,如下:
......public void run() { ......}......
如果您需要在线程A执行完成,得到返回值后,再继续执行某个业务。那么推荐您使用JDK1.5中提供的带有“执行返回值”的线程定义接口:Callable。
如果您还需要为多个线程的执行调度加入更复杂的控制逻辑,那么您需要我们之前讨论过的同步机制和JDK1.5中java.util.concurrent.locks包中的工具配合使用,才能达到效果。
JDK1.5的java.util.concurrent包中提供了一个Callable接口和一组相关机制,能够帮助程序员安全、快速、简洁的完成以上的功能(线程执行完成后,返回一个执行结果)。Callable接口中需要实现的接口方法为call(),这个方法有一个泛化的返回值 V,可以帮助您返回定义的任何一种对象结果。接口源代码如下:
public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception;}
下面我们通过一段简单的代码,看一下Callable接口是如何完成执行结果的返回和激活等待线程的:
package test.thread.base.callfurther;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.TimeUnit;/** * 测试可监控状态的线程 * @author yinwenjie * @param <V> */public class MyCallableThread<V extends Entity> implements Callable<V> { private V resultsEntity; public MyCallableThread(V param) { this.resultsEntity = param; } /* (non-Javadoc) * @see java.util.concurrent.Callable#call() */ @Override public V call() throws Exception { try { // 等待一段时间,模拟业务执行过程 synchronized (this) { this.wait(5000); } // 设置返回结果 this.resultsEntity.setStatus(1); } catch(Exception e) { // 执行错误了,也设置 this.resultsEntity.setStatus(-1); } return this.resultsEntity; } public static void main(String[] args) throws Exception { //这是您定义的一个模型对象。里面有一个status属性 MyCallableThread<Entity> callableThread = new MyCallableThread<Entity>(new Entity()); // Callable需要在线程池中执行 ExecutorService es = Executors.newFixedThreadPool(1); Future<Entity> future = es.submit(callableThread); // main线程会在这里等待,知道callableThread任务执行完成 Entity result = future.get(); System.out.println("result.status = " + result.getStatus()); // 停止线程池工作 es.shutdown(); es.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); }}
从以上给出的使用代码,包括以下几个实际动作:
Entity这个class,是为了记录线程执行的返回结果由我们自行定义的一个Class。实际上,对于MyCallableThread来说,只要继承了Entity的所有子类,都是可以作为它的泛化值的。
目前Callable定义的线程任务,只能放入线程池中,由线程池中的任务进行执行。没有类似于Runnable接口那样,new Thread(new MyDefindRunnable())并且start()的线程运行方式。
- 如果您不想使用线程池管理任务的执行,又不能直接将Callable接口的任务放入Thread,那么您只能借助一个工具类:FutureTask。使用方式如下:
FutureTask<Entity> futureTask = new FutureTask<Entity>(callableThread);new Thread(futureTask).start();
Future用于描述当前任务线程的执行状态。您可以使用isDone、isCancelled等方法,来获取当前任务线程的执行状态。
Future接口中的get方法,将会是当前线程进入阻塞状态。直到目标线程执行完毕,并且得到目标线程的返回结果。
Waits if necessary for the computation to complete, and then retrieves its result.
Returns: the computed result
Throws:
CancellationException - if the computation was cancelled
ExecutionException - if the computation threw an exception
InterruptedException - if the current thread was interrupted while waiting
3、JDK新特性锁:java.util.concurrent.locks包
java.util.concurrent有一个locks子包,这个子包提供了一种JDK1.5版本中设计的一种新的锁机制。其中重要的包括两种类型的锁:ReentrantLock通用锁和ReentrantReadWriteLock读写锁。这个小结我们主要介绍这两种新得锁形态的使用。
3-1、Lock->ReentrantLock通用锁
在JDK1.5版本中,Doug Lea加入了两种新的对象锁方式,ReentrantLock和ReentrantReadWriteLock。在之前的版本中,如果我们要为某个线程中操作的对象加锁,写法如下:
......synchronized (ThreadLock.WAIT_OBJECT) { ThreadLock.LOGGER.info("做了一些事情。。。。");}......
这个需要加锁的对象进行同步检查,同步边界内的代码只允许某一条线程A进入,除非线程A退出了同步边界或者通过wait等方法进入了阻塞状态,这段代码才允许其他线程访问。
在使用synchronized关键字的时候,您还需要特别关注interrupt异常。实际上这是因为JVM不允许停止“正在等待同步锁”的线程(这是更深入的知识点了)。
那么如果您使用ReentrantLock为多个线程在共享资源的线程块进行阻塞控制,就要比使用synchronized关键字简单许多(至少从表面现象来看是这样的),而且您不需要特别关注interrupt异常(至少从表面现象来看是这样的)。
还记得我们在《线程基础:线程(2)——JAVA中的基本线程操作(上) 》这篇文章中,给出的一段在多线程情况下使用对象锁的最简单代码吗?没事,不用特意去翻这篇文章,这里我们再给出一次就行了(为了节约篇幅,只给重要的代码片段):
....../** * 拿来加锁的对象 */private static final Object WAIT_OBJECT = new Object();......Thread threadA = new Thread(new Runnable() { @Override public void run() { // 检查'对象锁'状态。 synchronized (ThreadLock.WAIT_OBJECT) { ThreadLock.LOGGER.info("做了一些事情。。。。"); } }});Thread threadB = new Thread(new Runnable() { @Override public void run() { // 检查'对象锁'状态。 synchronized (ThreadLock.WAIT_OBJECT) { ThreadLock.LOGGER.info("做了另一些事情。。。。"); } }});threadA.start();threadB.start();......
现在我们使用ReentrantLock方式,对之前这段代码进行更改:
......public void test() { final ReentrantLock objectLock = new ReentrantLock(); new Thread() { public void run() { objectLock.lock(); TestReentrantLock.LOG.info("做了一些事情。。。。"); objectLock.unlock(); } }.start(); new Thread() { public void run() { objectLock.lock(); TestReentrantLock.LOG.info("做了另一些事情。。。。"); objectLock.unlock(); } }.start();}......
很显然,下面使用ReentrantLock方式改写后的代码是不是好理解多了。实际上最直观的理解就是将synchronized关键字的边界换成了 lock和unlock方法(但事实上并非如此)。至少线程您不需要关心interrupt异常了。
3-2、ReadWriteLock->ReentrantReadWriteLock读写锁
在java.util.concurrent.locks包中,还提供了一个ReentrantReadWriteLock工具。很显然,根据这个类的名字就明白了它的含义,即将多个线程对指定对象的读操作和写操作分开加锁。
我们可以使用以下代码,来获取对象的写锁
WriteLock writeLock = objectLock.writeLock();
使用以下代码,来获取对象的读锁:
ReadLock readLock = objectLock.readLock();
那么对象的写锁和读锁是怎么互相影响的呢?这个需要分开进行描述,首先我们来讨论一下,什么情况下线程可以获取某个对象的读锁:
- 如果没有任何线程获取了对象的写锁。
- 虽然有线程获取了对象的写锁,但是这个线程就是当前请求读锁的线程
那么当前是否有线程获取了对象的读锁,并不会影响当前线程继续获取对象的读锁。什么情况下线程可以获取某个对象的写锁:
- 没有任何线程获取了这个对象的读锁
- 没有任何线程获取了这个对象的写锁
注意,这里没有“虽然”的说法。也就是说,在同一个线程中的以下这种写法将会导致死锁:
......ReadLock readLock = objectLock.readLock();readLock.lock();WriteLock writeLock = objectLock.writeLock();// 线程操作会被一直阻塞在这里writeLock.lock();......
但是,同一个线程中的以下这种写法,就没有问题:
......WriteLock writeLock = objectLock.writeLock();writeLock.lock();ReadLock readLock = objectLock.readLock();readLock.lock();......
以下是所有示例代码:
package test.thread.reentrant;import java.util.concurrent.locks.ReentrantReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.log4j.BasicConfigurator;public class TestReadWriteReentrantLock { static { BasicConfigurator.configure(); } /** * 日志 */ private static final Log LOG = LogFactory.getLog(TestReadWriteReentrantLock.class); public static void main(String[] args) throws RuntimeException { new TestReadWriteReentrantLock().test(); } public void test() { final ReentrantReadWriteLock objectLock = new ReentrantReadWriteLock(); Thread thread1 = new Thread() { public void run() { WriteLock writeLock = objectLock.writeLock(); writeLock.lock(); TestReadWriteReentrantLock.LOG.info("做了一些写操作的事情。。。。"); writeLock.unlock(); } }; Thread thread2 = new Thread() { public void run() { WriteLock writeLock = objectLock.writeLock(); writeLock.lock(); TestReadWriteReentrantLock.LOG.info("做了另一些写操作的事情。。。。"); writeLock.unlock(); } }; Thread thread3 = new Thread() { public void run() { ReadLock readLock = objectLock.readLock(); readLock.lock(); TestReadWriteReentrantLock.LOG.info("做了一些读操作的事情。。。。"); readLock.unlock(); } }; //thread1、thread2、thread3在运行过程中,将按照我们之前描述的规律,相互作用 thread1.start(); thread2.start(); // 您可以使用thread1.interrupt()指令对ReentrantLock的影像。 // 您可以发现,thread1在加锁后并不会抛出interruptException异常 // 至少在我们这种使用方式下,不会抛出异常 // thread1.interrupt(); thread3.start(); }}
这里要重点说明一下,在大多数情况下您使用sycnchronized关键字或者使用ReentrantLock方式,都没有问题(这是因为90%的情况下,sycnchronized并不会真正的阻塞)。完全没有必要为了使用性能更好的ReentrantLock方式,而改变您历史代码版本中的sycnchronized关键字。
后续如果有时间,我将和大家讨论sycnchronized方式和ReentrantLock方式在工作原理上的不同。但是由于我在这个专栏上耗费了太多时间,所以只有暂缓。如果您想马上深入理解他们的工作原理,这里我推荐一篇文章:(http://www.ibm.com/developerworks/library/j-jtp10264/)
下文中,我们将以一个“赛跑”的例子,讲解JDK1.5环境下一些线程控制工具(包括Semaphore、CountDownLatch和java.util.concurrent.atomic子包)。并且复习这个专题讲到的知识点:同步快、锁、线程池、BlockingQueue、Callable等。当然还有线程间数据传递的方式。
(接下文)
- 线程基础:JDK1.5+(8)——线程新特性(上)
- 线程基础:JDK1.5+(9)——线程新特性(中)
- 线程基础:JDK1.5+(10)——线程新特性(下)
- java基础——泛型(jdk1.5新特性)
- 黑马程序员——多个生产者,多个消费者 signalAll() JDK1.5线程新特性
- 黑马程序员----多线程3(线程间通信、JDK1.5新特性、线程类的其他方法)
- 黑马程序员——java基础日记——多线程(2)——线程间通信与JDK1.5新特性
- 黑马程序员-JDK1.5新特性之多线程并发库
- Java--jdk1.5新特性线程池用法
- jdk1.7线程并发的新特性
- java基础——枚举(jdk1.5的新特性)
- 黑马程序员——基础加强(jdk1.5新特性)
- jdk1.5新特性(-)
- Java基础——JDK1.5版本新特性
- 黑马程序员——java基础---JDK1.5新特性
- 黑马程序员_基础加强(jdk1.5新特性)
- 黑马程序员--基础加强(JDK1.5新特性)
- java基础加强(JDK1.5新特性)
- 一步步搭建web服务器(4)
- 解决IE6、7、8使用JSON.stringify报JSON未定义错误的问题
- Mac环境下搭建Python爬虫环境
- 浅谈 RxAndroid + Retrofit + Databinding
- 2016蓝桥杯基础训练——数列特征
- 线程基础:JDK1.5+(8)——线程新特性(上)
- tsiLetatoR.61
- Android6.0动态权限处理
- (学习笔记)第六章 非刚性人脸跟踪——annotation(标记)
- 史上最详细的Highcharts使用指南
- 能说easyui的性能太烂了吗?
- 天声人語 20160202 米大統領レースの号砲
- 日经春秋 20160202
- Duplicate files copied in APK META-INF/DEPENDENCIES 解决办法