并发编程：（六）共享模型之不可变

一、日期转换的问题

由于 SimpleDateFormat 不是线程安全的，有很大几率出现 java.lang.NumberFormatException 或者出现不正确的日期解析结果。

public class Test1 {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    System.out.println(sdf.parse("1998-07-24"));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

运行部分结果：

Exception in thread "Thread-0" Exception in thread "Thread-2" Exception in thread "Thread-1" Exception in thread "Thread-3" Exception in thread "Thread-5" Exception in thread "Thread-4" 
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2089)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.itan.test5.Test2.lambda$main$0(Test2.java:12)
	at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: For input string: ".19981998"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:578)
	at java.lang.Long.parseLong(Long.java:631)
	at java.text.DigitList.getLong(DigitList.java:195)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
	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 com.itan.test5.Test2.lambda$main$0(Test2.java:12)
	at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: multiple points
	at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1890)
	at sun.misc.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.lang.Double.parseDouble(Double.java:538)
	at java.text.DigitList.getDouble(DigitList.java:169)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2089)
	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162)
	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
	at java.text.DateFormat.parse(DateFormat.java:364)
	at com.itan.test5.Test2.lambda$main$0(Test2.java:12)
	at java.lang.Thread.run(Thread.java:748)
Fri Jul 24 00:00:00 CST 1998
Fri Jul 24 00:00:00 CST 1998
Fri Jul 24 00:00:00 CST 1998
Fri Jul 24 00:00:00 CST 1998

二、解决方法之同步锁

虽然加锁能解决问题，但是会有性能上的损失，所以不建议使用此种方法

public class Test2 {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                synchronized (sdf){
                    try {
                        System.out.println(sdf.parse("1998-07-24"));
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

三、解决方法之DateTimeFormatter

查看源码说明知道：This class is immutable and thread-safe（这个类是不可变的和线程安全的）

public class Test3 {
    public static void main(String[] args) {
        DateTimeFormatter stf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                TemporalAccessor parse = stf.parse("1998-07-24");
                System.out.println(parse);
            }).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的使用

String类中所有属性都是 final 的

• 属性用 final 修饰保证了该属性是只读的，不能修改
• 类用 final 修饰保证了该类中的方法不能被覆盖，防止子类无意间破坏不可变性。

2、保护性拷贝

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

发现其内部都是调用 String 的构造方法创建了一个新字符串，再来看构造方法，是否对 final char[] value 做出了修改：

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

结果发现也没有，构造新字符串对象时，会生成新的 char[] value，对原有内容进行复制。这种通过创建副本对象来避免共享的手段称之为 保护性拷贝（defensive copy）

五、享元模式

1、简介

享元模式（Flyweight pattern），23种设计模式之一，如果在一个系统中存在多个相同的对象，那么只需要共享一份对象的拷贝，而不必为每一次使用都创建新的对象。目的是提高系统性能。

2、体现

在 JDK 中Boolean，Byte，Short，Integer，Long，Character 等包装类提供了 valueOf 方法，例如 Long 的 valueOf 对象会缓存 -128~127 之间的 Long 对象，在这个范围之间会重用对象，超出范围，才会新建 Long 对象。

public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}

注意：

• Byte，Short，Long 缓存的范围都是 -128~127
• Character 缓存的范围是 0~127
• Integer 的默认范围是 -128~127，最小值不能变，但最大值可以通过调整虚拟机参数 -Djava.lang.Integer.integerCache.high来改变
• Boolean 缓存了 True 和 False

六、final原理

对于final域，编译器和处理器要遵守两个重排序规则：

1、在构造函数内对一个 final 域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。

先写入final变量，后调用该对象引用

原因：编辑器会在 final 域的写之后，插入一个 StoreStore 屏障

2、初次读一个包含 final 域的对象的引用，与随后初次读这个 final 域，这两个操作之间不能重排序。

先读对象的引用，后读 final 变量

原因：编辑器会在读 final 域操作的前面插入一个 LoadLoad 屏障