Java多线程之Callable和其他Lock锁的使用（四）

2024-05-26 12:08
文章标签 java 使用 多线程 lock callable

本文主要是介绍Java多线程之Callable和其他Lock锁的使用（四），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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() {......
}
......
  • 1
  • 2
  • 3
  • 4
  • 5

如果您需要在线程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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

下面我们通过一段简单的代码，看一下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()*/@Overridepublic 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);}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

从以上给出的使用代码，包括以下几个实际动作：

  • 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();
  • 1
  • 2

  • 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("做了一些事情。。。。");
}
......
  • 1
  • 2
  • 3
  • 4
  • 5

这个需要加锁的对象进行同步检查，同步边界内的代码只允许某一条线程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() {@Overridepublic void run() {// 检查'对象锁'状态。synchronized (ThreadLock.WAIT_OBJECT) {ThreadLock.LOGGER.info("做了一些事情。。。。");}}
});Thread threadB = new Thread(new Runnable() {@Overridepublic void run() {// 检查'对象锁'状态。synchronized (ThreadLock.WAIT_OBJECT) {ThreadLock.LOGGER.info("做了另一些事情。。。。");}}
});
threadA.start();
threadB.start();
......
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

现在我们使用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();
}
......
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

很显然，下面使用ReentrantLock方式改写后的代码是不是好理解多了。实际上最直观的理解就是将synchronized关键字的边界换成了 lock和unlock方法（但事实上并非如此）。至少线程您不需要关心interrupt异常了。

3-2、ReadWriteLock->ReentrantReadWriteLock读写锁

在java.util.concurrent.locks包中，还提供了一个ReentrantReadWriteLock工具。很显然，根据这个类的名字就明白了它的含义，即将多个线程对指定对象的读操作和写操作分开加锁。

我们可以使用以下代码，来获取对象的写锁

WriteLock writeLock = objectLock.writeLock();
  • 1

使用以下代码，来获取对象的读锁：

ReadLock readLock = objectLock.readLock();
  • 1

那么对象的写锁和读锁是怎么互相影响的呢？这个需要分开进行描述，首先我们来讨论一下，什么情况下线程可以获取某个对象的读锁：

  • 如果没有任何线程获取了对象的写锁。
  • 虽然有线程获取了对象的写锁，但是这个线程就是当前请求读锁的线程

那么当前是否有线程获取了对象的读锁，并不会影响当前线程继续获取对象的读锁。什么情况下线程可以获取某个对象的写锁：

  • 没有任何线程获取了这个对象的读锁
  • 没有任何线程获取了这个对象的写锁

注意，这里没有“虽然”的说法。也就是说，在同一个线程中的以下这种写法将会导致死锁：

......
ReadLock readLock = objectLock.readLock();
readLock.lock();
WriteLock writeLock = objectLock.writeLock();
// 线程操作会被一直阻塞在这里
writeLock.lock();
......
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

但是，同一个线程中的以下这种写法，就没有问题：

......
WriteLock writeLock = objectLock.writeLock();
writeLock.lock();
ReadLock readLock = objectLock.readLock();
readLock.lock();
......
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

以下是所有示例代码：

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();}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

这里要重点说明一下，在大多数情况下您使用sycnchronized关键字或者使用ReentrantLock方式，都没有问题（这是因为90%的情况下，sycnchronized并不会真正的阻塞）。完全没有必要为了使用性能更好的ReentrantLock方式，而改变您历史代码版本中的sycnchronized关键字。

后续如果有时间，我将和大家讨论sycnchronized方式和ReentrantLock方式在工作原理上的不同。但是由于我在这个专栏上耗费了太多时间，所以只有暂缓。如果您想马上深入理解他们的工作原理，这里我推荐一篇文章：（http://www.ibm.com/developerworks/library/j-jtp10264/）

来源：http://blog.csdn.net/yinwenjie

这篇关于Java多线程之Callable和其他Lock锁的使用（四）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1004419。

相关文章

分布式锁在Spring Boot应用中的实现过程

分布式锁在Spring Boot应用中的实现过程

《分布式锁在SpringBoot应用中的实现过程》文章介绍在SpringBoot中通过自定义Lock注解、LockAspect切面和RedisLockUtils工具类实现分布式锁,确保多实例并发操作... 目录Lock注解LockASPect切面RedisLockUtils工具类总结在现代微服务架构中，分布
阅读更多...
Java使用Thumbnailator库实现图片处理与压缩功能

Java使用Thumbnailator库实现图片处理与压缩功能

《Java使用Thumbnailator库实现图片处理与压缩功能》Thumbnailator是高性能Java图像处理库,支持缩放、旋转、水印添加、裁剪及格式转换,提供易用API和性能优化,适合Web应... 目录1. 图片处理库Thumbnailator介绍2. 基本和指定大小图片缩放功能2.1 图片缩放的
阅读更多...
Spring Boot集成/输出/日志级别控制/持久化开发实践

Spring Boot集成/输出/日志级别控制/持久化开发实践

《SpringBoot集成/输出/日志级别控制/持久化开发实践》SpringBoot默认集成Logback,支持灵活日志级别配置（INFO/DEBUG等）,输出包含时间戳、级别、类名等信息,并可通过... 目录一、日志概述1.1、Spring Boot日志简介1.2、日志框架与默认配置1.3、日志的核心作用
阅读更多...
Python使用Tenacity一行代码实现自动重试详解

Python使用Tenacity一行代码实现自动重试详解

《Python使用Tenacity一行代码实现自动重试详解》tenacity是一个专为Python设计的通用重试库,它的核心理念就是用简单、清晰的方式,为任何可能失败的操作添加重试能力,下面我们就来看... 目录一切始于一个简单的 API 调用Tenacity 入门：一行代码实现优雅重试精细控制：让重试按我
阅读更多...
破茧 JDBC:MyBatis 在 Spring Boot 中的轻量实践指南

破茧 JDBC:MyBatis 在 Spring Boot 中的轻量实践指南

《破茧JDBC:MyBatis在SpringBoot中的轻量实践指南》MyBatis是持久层框架,简化JDBC开发,通过接口+XML/注解实现数据访问,动态代理生成实现类,支持增删改查及参数... 目录一、什么是 MyBATis二、 MyBatis 入门2.1、创建项目2.2、配置数据库连接字符串2.3、入
阅读更多...
Springboot项目启动失败提示找不到dao类的解决

Springboot项目启动失败提示找不到dao类的解决

《Springboot项目启动失败提示找不到dao类的解决》SpringBoot启动失败,因ProductServiceImpl未正确注入ProductDao,原因：Dao未注册为Bean,解决：在启... 目录错误描述原因解决方法总结***************************APPLICA编
阅读更多...
深度解析Spring Security 中的 SecurityFilterChain核心功能

深度解析Spring Security 中的 SecurityFilterChain核心功能

《深度解析SpringSecurity中的SecurityFilterChain核心功能》SecurityFilterChain通过组件化配置、类型安全路径匹配、多链协同三大特性,重构了Spri... 目录Spring Security 中的SecurityFilterChain深度解析一、Security
阅读更多...
MySQL中EXISTS与IN用法使用与对比分析

MySQL中EXISTS与IN用法使用与对比分析

《MySQL中EXISTS与IN用法使用与对比分析》在MySQL中,EXISTS和IN都用于子查询中根据另一个查询的结果来过滤主查询的记录,本文将基于工作原理、效率和应用场景进行全面对比... 目录一、基本用法详解1. IN 运算符2. EXISTS 运算符二、EXISTS 与 IN 的选择策略三、性能对比
阅读更多...
SpringBoot多环境配置数据读取方式

SpringBoot多环境配置数据读取方式

《SpringBoot多环境配置数据读取方式》SpringBoot通过环境隔离机制,支持properties/yaml/yml多格式配置,结合@Value、Environment和@Configura... 目录一、多环境配置的核心思路二、3种配置文件格式详解2.1 properties格式（传统格式）1.
阅读更多...
Apache Ignite 与 Spring Boot 集成详细指南

Apache Ignite 与 Spring Boot 集成详细指南

《ApacheIgnite与SpringBoot集成详细指南》ApacheIgnite官方指南详解如何通过SpringBootStarter扩展实现自动配置,支持厚/轻客户端模式,简化Ign... 目录 一、背景：为什么需要这个集成？ 二、两种集成方式（对应两种客户端模型） 三、方式一：自动配置 Thick
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2