共计 7544 个字符,预计需要花费 19 分钟才能阅读完成。
1. 什么是线程不平安?
线程不平安也叫非线程平安,是指 多线程执行中,程序的执行后果和预期的后果不符的状况就叫做线程不平安。
线程不平安的代码
SimpleDateFormat
就是一个典型的线程不平安事例,接下来咱们入手来实现一下。首先咱们先创立 10 个线程来格式化工夫,工夫格式化每次传递的待格式化工夫都是不同的,所以程序如果正确执行将会打印 10 个不同的值,接下来咱们来看具体的代码实现:
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SimpleDateFormatExample {
// 创立 SimpleDateFormat 对象
private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
public static void main(String[] args) {
// 创立线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// 执行 10 次工夫格式化
for (int i = 0; i < 10; i++) {
int finalI = i;
// 线程池执行工作
threadPool.execute(new Runnable() {
@Override
public void run() {
// 创立工夫对象
Date date = new Date(finalI * 1000);
// 执行工夫格式化并打印后果
System.out.println(simpleDateFormat.format(date));
}
});
}
}
}
咱们预期的正确后果是这样的(10 次打印的值都不同):
然而,以上程序的运行后果却是这样的:
从上述后果能够看出,当在多线程中应用 SimpleDateFormat
进行工夫格式化是线程不平安的。
2. 解决方案
SimpleDateFormat
线程不平安的解决方案总共蕴含以下 5 种:
- 将
SimpleDateFormat
定义为局部变量; - 应用
synchronized
加锁执行; - 应用
Lock
加锁执行(和解决方案 2 相似); - 应用
ThreadLocal
; - 应用
JDK 8
中提供的DateTimeFormat
。
接下来咱们别离来看每种解决方案的具体实现。
① 将 SimpleDateFormat 变为局部变量
将 SimpleDateFormat
定义为局部变量时,因为每个线程都是独享 SimpleDateFormat
对象的,相当于将多线程程序变成“单线程”程序了,所以不会有线程不平安的问题,具体实现代码如下:
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SimpleDateFormatExample {public static void main(String[] args) {
// 创立线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// 执行 10 次工夫格式化
for (int i = 0; i < 10; i++) {
int finalI = i;
// 线程池执行工作
threadPool.execute(new Runnable() {
@Override
public void run() {
// 创立 SimpleDateFormat 对象
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
// 创立工夫对象
Date date = new Date(finalI * 1000);
// 执行工夫格式化并打印后果
System.out.println(simpleDateFormat.format(date));
}
});
}
// 工作执行完之后敞开线程池
threadPool.shutdown();}
}
以上程序的执行后果为:
当打印的后果都不雷同时,示意程序的执行是正确的,从上述后果能够看出,将 SimpleDateFormat
定义为局部变量之后,就能够胜利的解决线程不平安问题了。
② 应用 synchronized 加锁
锁是解决线程不平安问题最罕用的伎俩,接下来咱们先用 synchronized
来加锁进行工夫格式化,实现代码如下:
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SimpleDateFormatExample2 {
// 创立 SimpleDateFormat 对象
private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
public static void main(String[] args) {
// 创立线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// 执行 10 次工夫格式化
for (int i = 0; i < 10; i++) {
int finalI = i;
// 线程池执行工作
threadPool.execute(new Runnable() {
@Override
public void run() {
// 创立工夫对象
Date date = new Date(finalI * 1000);
// 定义格式化的后果
String result = null;
synchronized (simpleDateFormat) {
// 工夫格式化
result = simpleDateFormat.format(date);
}
// 打印后果
System.out.println(result);
}
});
}
// 工作执行完之后敞开线程池
threadPool.shutdown();}
}
以上程序的执行后果为:
③ 应用 Lock 加锁
在 Java 语言中,锁的罕用实现形式有两种,除了 synchronized
之外,还能够应用手动锁 Lock
,接下来咱们应用 Lock
来对线程不平安的代码进行革新,实现代码如下:
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Lock 解决线程不平安问题
*/
public class SimpleDateFormatExample3 {
// 创立 SimpleDateFormat 对象
private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
public static void main(String[] args) {
// 创立线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// 创立 Lock 锁
Lock lock = new ReentrantLock();
// 执行 10 次工夫格式化
for (int i = 0; i < 10; i++) {
int finalI = i;
// 线程池执行工作
threadPool.execute(new Runnable() {
@Override
public void run() {
// 创立工夫对象
Date date = new Date(finalI * 1000);
// 定义格式化的后果
String result = null;
// 加锁
lock.lock();
try {
// 工夫格式化
result = simpleDateFormat.format(date);
} finally {
// 开释锁
lock.unlock();}
// 打印后果
System.out.println(result);
}
});
}
// 工作执行完之后敞开线程池
threadPool.shutdown();}
}
以上程序的执行后果为:
从上述代码能够看出,手动锁的写法相比于 synchronized
要繁琐一些。
④ 应用 ThreadLocal
加锁计划尽管能够正确的解决线程不平安的问题,但同时也引入了新的问题,加锁会让程序进入排队执行的流程,从而肯定水平的升高了程序的执行效率,如下图所示:
那有没有一种计划既能解决线程不平安的问题,同时还能够防止排队执行呢?
答案是有的,能够思考应用 ThreadLocal
。ThreadLocal
翻译为中文是线程本地变量的意思,字如其人 ThreadLocal
就是用来创立线程的公有(本地)变量的,每个线程领有本人的公有对象,这样就能够防止线程不平安的问题了,实现如下:
晓得了实现计划之后,接下来咱们应用具体的代码来演示一下 ThreadLocal
的应用,实现代码如下:
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* ThreadLocal 解决线程不平安问题
*/
public class SimpleDateFormatExample4 {
// 创立 ThreadLocal 对象,并设置默认值(new SimpleDateFormat)private static ThreadLocal<SimpleDateFormat> threadLocal =
ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss"));
public static void main(String[] args) {
// 创立线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// 执行 10 次工夫格式化
for (int i = 0; i < 10; i++) {
int finalI = i;
// 线程池执行工作
threadPool.execute(new Runnable() {
@Override
public void run() {
// 创立工夫对象
Date date = new Date(finalI * 1000);
// 格式化工夫
String result = threadLocal.get().format(date);
// 打印后果
System.out.println(result);
}
});
}
// 工作执行完之后敞开线程池
threadPool.shutdown();}
}
以上程序的执行后果为:
ThreadLocal 和局部变量的区别
首先来说 ThreadLocal
不等于局部变量,这里的“局部变量”指的是像 2.1 示例代码中的局部变量,ThreadLocal
和局部变量最大的区别在于:ThreadLocal
属于线程的公有变量,如果应用的是线程池,那么 ThreadLocal
中的变量是能够重复使用的,而代码级别的局部变量,每次执行时都会创立新的局部变量,二者区别如下图所示:
更多对于 ThreadLocal
的内容,能够拜访磊哥后面的文章《ThreadLocal 不好用?那是你没用对!》。
⑤ 应用 DateTimeFormatter
以上 4 种解决方案都是因为 SimpleDateFormat
是线程不平安的,所以咱们须要加锁或者应用 ThreadLocal
来解决,然而,JDK 8
之后咱们就有了新的抉择,如果应用的是 JDK 8+
版本,就能够间接应用 JDK 8
中新增的、平安的工夫格式化工具类 DateTimeFormatter
来格式化工夫了,接下来咱们来具体实现一下。
应用 DateTimeFormatter
必须要配合 JDK 8
中新增的工夫对象 LocalDateTime
来应用,因而在操作之前,咱们能够先将 Date
对象转换成 LocalDateTime
,而后再通过 DateTimeFormatter
来格式化工夫,具体实现代码如下:
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* DateTimeFormatter 解决线程不平安问题
*/
public class SimpleDateFormatExample5 {
// 创立 DateTimeFormatter 对象
private static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("mm:ss");
public static void main(String[] args) {
// 创立线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
// 执行 10 次工夫格式化
for (int i = 0; i < 10; i++) {
int finalI = i;
// 线程池执行工作
threadPool.execute(new Runnable() {
@Override
public void run() {
// 创立工夫对象
Date date = new Date(finalI * 1000);
// 将 Date 转换成 JDK 8 中的工夫类型 LocalDateTime
LocalDateTime localDateTime =
LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
// 工夫格式化
String result = dateTimeFormatter.format(localDateTime);
// 打印后果
System.out.println(result);
}
});
}
// 工作执行完之后敞开线程池
threadPool.shutdown();}
}
以上程序的执行后果为:
3. 线程不平安起因剖析
要理解 SimpleDateFormat
为什么是线程不平安的?咱们须要查看并剖析 SimpleDateFormat
的源码才行,那咱们先从应用的办法 format
动手,源码如下:
private StringBuffer format(Date date, StringBuffer toAppendTo,
FieldDelegate delegate) {
// 留神此行代码
calendar.setTime(date);
boolean useDateFormatSymbols = useDateFormatSymbols();
for (int i = 0; i < compiledPattern.length;) {int tag = compiledPattern[i] >>> 8;
int count = compiledPattern[i++] & 0xff;
if (count == 255) {count = compiledPattern[i++] << 16;
count |= compiledPattern[i++];
}
switch (tag) {
case TAG_QUOTE_ASCII_CHAR:
toAppendTo.append((char)count);
break;
case TAG_QUOTE_CHARS:
toAppendTo.append(compiledPattern, i, count);
i += count;
break;
default:
subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
break;
}
}
return toAppendTo;
}
兴许是好运使然,没想到刚开始剖析第一个办法就找到了线程不平安的问题所在。
从上述源码能够看出,在执行 SimpleDateFormat.format
办法时,会应用 calendar.setTime
办法将输出的工夫进行转换,那么咱们设想一下这样的场景:
- 线程 1 执行了
calendar.setTime(date)
办法,将用户输出的工夫转换成了前面格式化时所须要的工夫; - 线程 1 暂停执行,线程 2 失去
CPU
工夫片开始执行; - 线程 2 执行了
calendar.setTime(date)
办法,对工夫进行了批改; - 线程 2 暂停执行,线程 1 得出
CPU
工夫片继续执行,因为线程 1 和线程 2 应用的是同一对象,而工夫曾经被线程 2 批改了,所以此时当线程 1 继续执行的时候就会呈现线程平安的问题了。
失常的状况下,程序的执行是这样的:
非线程平安的执行流程是这样的:
在多线程执行的状况下,线程 1 的 date1
和线程 2 的 date2
,因为执行程序的问题,最终都被格式化成 date2 formatted
,而非线程 1 date1 formatted
和线程 2 date2 formatted
,这样就会导致线程不平安的问题。
4. 各计划优缺点总结
如果应用的是 JDK 8+
版本,能够间接应用线程平安的 DateTimeFormatter
来进行工夫格式化,如果应用的 JDK 8
以下版本或者革新老的 SimpleDateFormat
代码,能够思考应用 synchronized
或 ThreadLocal
来解决线程不平安的问题。因为实现计划 1 局部变量的解决方案,每次执行的时候都会创立新的对象,因而不举荐应用。synchronized
的实现比较简单,而应用 ThreadLocal
能够防止加锁排队执行的问题。
关注公号「Java 中文社群」查看更多有意思、涨常识的并发编程文章。