一、日期转换的问题
1、问题提出
下面的代码在运行时,由于 SimpleDateFormat 不是线程安全的
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
log.debug("{}", sdf.parse("1951-04-21"));
} catch (Exception e) {
log.error("{}", e);
}
}).start();
}
有很大几率出现 java.lang.NumberFormatException 或者出现不正确的日期解析结果,例如:
10:40:00.528 [Thread-2] DEBUG p7_1.Test1 - Sat Apr 21 00:00:00 CST 1951
10:40:00.531 [Thread-0] ERROR p7_1.Test1 - {}
java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:601)
at java.lang.Long.parseLong(Long.java:631)
at java.text.DigitList.getLong(DigitList.java:195)
at java.text.DecimalFormat.parse(DecimalFormat.java:2051)
at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
at java.text.DateFormat.parse(DateFormat.java:364)
at p7_1.Test1.lambda$main$0(Test1.java:18)
at java.lang.Thread.run(Thread.java:748)
10:40:00.529 [Thread-3] DEBUG p7_1.Test1 - Sat Apr 21 00:00:00 CST 1951
10:40:00.531 [Thread-1] ERROR p7_1.Test1 - {}
具体分析
DateFormat类
public abstract class DateFormat extends Format {
protected Calendar calendar;
public abstract Date parse(String source, ParsePosition pos);
public Date parse(String source) throws ParseException
{
ParsePosition pos = new ParsePosition(0);
Date result = parse(source, pos);
if (pos.index == 0)
throw new ParseException("Unparseable date: \"" + source + "\"" ,
pos.errorIndex);
return result;
}
}
SimpleDateFormat类
public class SimpleDateFormat extends DateFormat {
public Date parse(String text, ParsePosition pos)
{
// 省略部分代码
// 最后的返回值parsedDate
Date parsedDate;
try {
// 获取parsedDate通过调用calb.establish(calendar).getTime();
// 获取传的参数calendar是同一个calendar
parsedDate = calb.establish(calendar).getTime();
if (ambiguousYear[0]) {
if (parsedDate.before(defaultCenturyStart)) {
parsedDate = calb.addYear(100).establish(calendar).getTime();
}
}
}
catch (IllegalArgumentException e) {
pos.errorIndex = start;
pos.index = oldStart;
return null;
}
return parsedDate;
}
}
DateFormat类中维护了一个全局的Calendar变量,用于计算日期-时间字段和时间瞬间的Calendar实例。
CalendarBuilder类
方法里面先后调用了cal.clear()和cal.set(index, field[MAX_FIELD + index]),也就是先清除cal对象中设置的值,再重新设置新的值,由于Calendar内部没有线程安全机制,并且两个操作也不是原子性的,所以再多个线程同时操作一个SimpleDateFormat时就会引起cal值混乱。
Calendar establish(Calendar cal) {
boolean weekDate = isSet(WEEK_YEAR)
&& field[WEEK_YEAR] > field[YEAR];
if (weekDate && !cal.isWeekDateSupported()) {
// Use YEAR instead
if (!isSet(YEAR)) {
set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
}
weekDate = false;
}
cal.clear();
// Set the fields from the min stamp to the max stamp so that
// the field resolution works in the Calendar.
for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
for (int index = 0; index <= maxFieldIndex; index++) {
if (field[index] == stamp) {
cal.set(index, field[MAX_FIELD + index]);
break;
}
}
}
if (weekDate) {
int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
int dayOfWeek = isSet(DAY_OF_WEEK) ?
field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
if (dayOfWeek >= 8) {
dayOfWeek--;
weekOfYear += dayOfWeek / 7;
dayOfWeek = (dayOfWeek % 7) + 1;
} else {
while (dayOfWeek <= 0) {
dayOfWeek += 7;
weekOfYear--;
}
}
dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
}
cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
}
return cal;
}
因此,SimpleDateFormat线程不安全的根本原因:DateFormat类中的Calendar被多线程共享,而且Calendar对象本身线程不安全。
2、思路 - 同步锁
这样虽能解决问题,但带来的是性能上的损失,并不算很好:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
new Thread(() -> {
synchronized (sdf) {
try {
log.debug("{}", sdf.parse("1951-04-21"));
} catch (Exception e) {
log.error("{}", e);
}
}
}).start();
}
3、思路 - 不可变
如果一个对象不能够修改其内部状态(属性),那么它就是线程安全的,因为不存在并发修改啊!这样的对象在Java 中有很多,例如在 Java 8 后,提供了一个新的日期格式化类:
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
log.debug("{}", dtf.parse("1951-04-21"));
} catch (Exception e) {
log.error("{}", e);
}
}).start();
}
不可变对象,实际是另一种避免竞争的方式。
二、不可变设计
另一个大家更为熟悉的 String 类也是不可变的,以它为例,说明一下不可变设计的要素
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
// ...
}
1、final 的使用
发现该类、类中所有属性都是 final 的
- 属性用 final 修饰保证了该属性是只读的,不能修改
- 类用 final 修饰保证了该类中的方法不能被覆盖,防止子类无意间破坏不可变性
2、保护性拷贝
但有同学会说,使用字符串时,也有一些跟修改相关的方法啊,比如 substring 等,那么下面就看一看这些方法是如何实现的,就以 substring 为例:
public String substring(int var1) {
if (var1 < 0) {
throw new StringIndexOutOfBoundsException(var1);
} else {
int var2 = this.value.length - var1;
if (var2 < 0) {
throw new StringIndexOutOfBoundsException(var2);
} else {
return var1 == 0 ? this : new String(this.value, var1, var2);
}
}
}
发现其内部是调用 String 的构造方法创建了一个新字符串,再进入这个构造看看,是否对 final char[] value 做出了修改:
public String(char[] var1, int var2, int var3) {
if (var2 < 0) {
throw new StringIndexOutOfBoundsException(var2);
} else {
if (var3 <= 0) {
if (var3 < 0) {
throw new StringIndexOutOfBoundsException(var3);
}
if (var2 <= var1.length) {
this.value = "".value;
return;
}
}
if (var2 > var1.length - var3) {
throw new StringIndexOutOfBoundsException(var2 + var3);
} else {
this.value = Arrays.copyOfRange(var1, var2, var2 + var3);
}
}
}
结果发现也没有,构造新字符串对象时,会生成新的 char[] value,对内容进行复制 。这种通过创建副本对象来避免共享的手段称之为【保护性拷贝(defensive copy)】
3、final原理
理解了 volatile 原理,再对比 final 的实现就比较简单了
public class TestFinal {
final int a = 20;
}
字节码
0 aload_0
1 invokespecial #1 <java/lang/Object.<init>>
4 aload_0
5 bipush 20
7 putfield #2 <p7_1/TestFinal.a>
<-- 写屏障
10 return
发现 final 变量的赋值也会通过 putfield 指令来完成,同样在这条指令之后也会加入写屏障,保证在其它线程读到它的值时不会出现为 0 的情况。
三、无状态
在 web 阶段学习时,设计 Servlet 时为了保证其线程安全,都会有这样的建议,不要为 Servlet 设置成员变量,这种没有任何成员变量的类是线程安全的。
因为成员变量保存的数据也可以称为状态信息,因此没有成员变量就称之为【无状态】