JUC并发-共享模型-不可变

1、日期转换的问题

下面的代码在运行时，由于 SimpleDateFormat 不是线程安全的

@Slf4j(topic = "c.Test1")
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 {log.debug("{}", sdf.parse("1951-04-21"));} catch (Exception e) {log.error("{}", e);}                }).start();}}
}

有很大几率出现 java.lang.NumberFormatException 或者出现不正确的日期解析结果。

解决方案1：synchronized同步锁

@Slf4j(topic = "c.Test1")
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(() -> {// 解决方案1：synchronized解决 但对性能有影响synchronized (sdf) {	try {log.debug("{}", sdf.parse("1951-04-21"));} catch (Exception e) {log.error("{}", e);}}}).start();}}
}

解决方案2：DateTimeFormatter不可变

如果一个对象不能够修改其内部状态（属性），那么它就是线程安全的，因为不存在并发修改。在Java8后，提供了一个新的日期格式化类：DateTimeFormatter

@Slf4j(topic = "c.Test1")
public class Test1 {public static void main(String[] args) {// 解决方案2：DateTimeFormatter - This class is immutable（不可变） and thread-safeDateTimeFormatter stf = DateTimeFormatter.ofPattern("yyyy-MM-dd");for (int i = 0; i < 10; i++) {new Thread(() -> {TemporalAccessor parse = stf.parse("1951-04-21");log.debug("{}", parse);}).start();}}
}

2、不可变设计

String 类也是不可变的，以它为例，说明一下不可变设计的要素。

public final class String implements java.io.Serializable,Comparable<String>,CharSequence{/**Thevalueisusedforcharacterstorage.*///final修饰char数组，保证了它只能在构造方法构造的时候赋值private final char value[];/**Cachethehashcodeforthestring*//*hash用作缓存字符串生成的哈希码；* 只有在首次调用hashcode时，才会生成，* 之后就会把这个哈希值缓存到这个hash的成员变量里，* 然后以后就可以避免这个哈希值的计算了*/private int hash;//Default to 0//...
}

2.1 final 的使用

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

原理

如果一个变量被声明为final，会在赋值之后加入一个写屏障，保证写屏障前的指令不会被重排序到写屏障后面。保证写屏障之前的操作（修改、赋值....）能够被更新到主存中，其它线程可见。

2.2 保护性拷贝

使用字符串时，也有一些跟修改相关的方法，如 substring 等。但substring是调用String内部的构造方法创建了一个新的字符串，没有对原字符串进行修改。

通过创建副本对象来避免共享的手段叫作保护性拷贝。

3、享元模式

保护性拷贝的缺点是：创建的对象会比较多，占用内存。

3.1 定义

运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率。

3.2 体现

3.2.1 包装类

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

Long有一个静态内部类LongCache，它在初始化的时候会创建一个256的长整形包装类对象的数组，并且在初始化代码块里会实现将这256个对象全部都创建好，存入cache数组。

private static class LongCache{private LongCache(){}static final Long cache[]= new Long[-（-128)+ 127 + 1];static{for(int i=0;i<cache.length;i++)cache[i]]= new Long(i - 128);}
}

之后调用valueOf的时候，会直接从缓存数组中获取这个长整形对象避免对象的重复创建。

public static Long valueOf(long l) {final int offset = 128;if (l >= -128 && l <= 127) { // will cachereturn 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

3.2.2 自定义连接池

例如：一个线上商城应用，QPS达到数千，如果每次都重新创建和关闭数据库连接，性能会受到极大影响。这时预先创建好一批连接，放入连接池。一次请求到达后，从连接池获取连接，使用完毕后再还回连接池，这样既节约了连接的创建和关闭时间，也实现了连接的重用，不至于让庞大的连接数压垮数据库。

public class Test3 {public static void main(String[] args) {Pool pool = new Pool(2);for (int i = 0; i < 5; i++) {new Thread(() -> {Connection conn = pool.borrow();try {Thread.sleep(new Random().nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();}pool.free(conn);}).start();}}
}@Slf4j(topic = "c.Pool")
class Pool {// 1. 连接池大小 假设大小固定+finalprivate final int poolSize;// 2. 连接对象数组private Connection[] connections;// 3. 连接状态数组 0 表示空闲， 1 表示繁忙// AtomicIntegerArray对states数组做安全保护private AtomicIntegerArray states;// 4. 构造方法初始化public Pool(int poolSize) {this.poolSize = poolSize;this.connections = new Connection[poolSize];this.states = new AtomicIntegerArray(new int[poolSize]);for (int i = 0; i < poolSize; i++) {connections[i] = new MockConnection("连接" + (i+1));}}// 5. 借连接public Connection borrow() {while(true) {for (int i = 0; i < poolSize; i++) {// 获取空闲连接if(states.get(i) == 0) {if (states.compareAndSet(i, 0, 1)) {log.debug("borrow {}", connections[i]);return connections[i];}}}// 如果没有空闲连接，当前线程进入等待// 避免CPU空转，让线程获取不到资源就放弃对资源的抢占synchronized (this) {try {log.debug("wait...");this.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}// 6. 归还连接public void free(Connection conn) {for (int i = 0; i < poolSize; i++) {if (connections[i] == conn) {//归还连接的线程 就是 连接的持有者 不会发送竞争 不需要compareAndSetstates.set(i, 0);synchronized (this) {log.debug("free {}", conn);this.notifyAll();}break;}}}
}class MockConnection implements Connection {private String name;public MockConnection(String name) {this.name = name;}@Overridepublic String toString() {return "MockConnection{" +"name='" + name + '\'' +'}';}//......
}

以上实现没有考虑：