并发编程（第七章 共享模型之不可变）

本章内容

• 不可变类的使用
• 不可变类设计
• 无状态类设计

一、日期转换问题

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或者出现不正确的日期解析结果，例如：

2、思路-同步锁

这样虽然解决问题，但带来的是性能上的损失，并不算很好：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); 
for (int i = 0; i < 50; i++) {
	new Thread(() -> { 
		synchronized (sdf) {
			try {
				log.debug("{}", sdf.parse("1951-04-21"));
			} catch (Exception e) { 
				log.error("{}", e);
			} 
		}
	}).start(); 
}

3、思路-不可变

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

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); 
for (int i = 0; i < 10; i++) {
	new Thread(() -> {
		LocalDate date = dtf.parse("2018-10-01", LocalDate::from); 
		log.debug("{}", date);
	}).start(); 
}

可以看DateTimeFormatter的文档：

不可变对象，实际是另一种避免竞争的方式。

二、不可变设计

另一个大家更为熟悉的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 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;
		} 
	}
	if (offset > value.length - count) {
		throw new StringIndexOutOfBoundsException(offset + count);
	}
	this.value = Arrays.copyOfRange(value, offset, offset+count); 
}

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

3、模式之享元（重要）

3.1 简介

定义：英文名称：Flyweight pattern，当需要重用数量有限的同一类对象时；

• wikipedia: A flyweight is an object that minimizes memory usage by sharing as much data as possible with other similar objects

出自 "Gang of Four"design patterns
归类 Structual patterns

3.2 体现
3.2.1 包装类

在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

3.2.2 String串池
3.2.3 BigDecimal BigInteger
3.3 DIY

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

class Pool {
	// 1. 连接池大小
	private final int poolSize; // 2. 连接对象数组
	private Connection[] connections;
	// 3. 连接状态数组 0 表示空闲， 1 表示繁忙
	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];
			} 
		}
	}
	// 如果没有空闲连接，当前线程进入等待 
	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) {
				states.set(i, 0); 
				synchronized (this) {
					log.debug("free {}", conn);
					this.notifyAll(); 
				}
				break; 
			}
		} 
	}
}

class MockConnection implements Connection { 
	// 实现略
}

使用连接池：

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();
}

以上实现没有考虑：

• 连接的动态增长与收缩
• 连接保活（可用性检测）
• 等待超时处理
• 分布式hash

对于关系型数据库，有比较成熟的连接池实现，例如c3p0，druid等对于更通用的对象池，可以考虑使用apache commons pool，例如redis连接池可以参考jedis中关于连接池的实现

4、原理之final（重要）

1、设置final变量的原理

理解了volatile原理，再对比final的实现就比较简单了

public class TestFinal {
 	final int a = 20;
}

字节码：

发现final变量的赋值也会通过putfield指令来实现，同样在这条指令之后也会加入写屏障，保证在其它线程读到它的值时不会出现为0的情况。

2、获取final变量的原理

三、无状态

在web阶段学习时，设计Servlet时为了保证其线程安全，都会有这样的建议，不要为Servlet设置成员变量，这种没有任何成员变量的类是线程安全的。

• 因为成员变量保存的数据也可以称为状态信息，因此没有成员变量就称之为【无状态】

四、本章小结

• 不可变类使用
• 不可变类设计
• 原理方面
  – final
• 模式方面
  – 享元