---

前言

从（6）开始讨论一些不可变类。文章根据《Java并发编程的艺术》这本书以及黑马的视频 黑马多线程 做的笔记。

---

1. 日期转换的问题

对于日期类 SimpleDateFormat，由于 SimpleDateFormat 不是线程安全的，所以在多线程情况下，SimpleDateFormat 这个类的使用可能会出现异常，下面来演示这种情况：

  private static void test1() {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//定义10个线程进行解析操作for (int i = 0; i < 10; i++) {new Thread(() -> {try {log.debug("{}", sdf.parse("2021-2-4"));} catch (Exception e) {log.error("{}", e);}}).start();}}

java.lang.NumberFormatException: For input string: "202120212021E"
java.lang.NumberFormatException: For input string: ""
java.lang.NumberFormatException: multiple points
java.lang.NumberFormatException: multiple points

多线程下是不安全的，当然，我们可以使用 synchronized 来进行线程的同步，但是这样就有一个问题，就是程序的效率会降低

 private static void test2() {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();}}

JDK 8 中提供了一个新的日期格式化类，DateTimeFormatter，这个类内部是线程安全的，内部的状态不能被修改，所以我们使用 DateTimeFormatter 来替换 SimpleDateFormat，下面就是代码：

 private static void test3() {DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");for (int i = 0; i < 10; i++) {new Thread(() -> {//LocalDate.from方法，创建一个 LocalDate 实例LocalDate date = dtf.parse("2018-10-01", LocalDate::from);log.debug("{}", date);}).start();}}

通过上面的例子，可以得出一个结论：类的内部设计成不可改变的，也是一种线程安全的方法

2. 不可变设计

1. String类的设计：保护性拷贝

我们以 String 类为例子，来讲一下 String 是如何保证不可变的，随便找两个方法

1、subString

从下面的方法中可以看出来，最后返回的是一个新的字符串，是通过 new String创建出来的，注意这里 new 出来时存储在堆上的，所以从这个方法可以看出来，并没有对原来的字符串有做修改，而是重新创建了一个。而从构造方法中也可以看出来，其实内部是创建了一个新的数组来存储 String 值，所以原来的 String 其实并没有改变。就算是多线程情况下，线程安全也只会体现在创建了多个 String 对象上面，对原来的并没有修改动作。

 public String substring(int beginIndex) {if (beginIndex < 0) {throw new StringIndexOutOfBoundsException(beginIndex);}int subLen = value.length - beginIndex;if (subLen < 0) {throw new StringIndexOutOfBoundsException(subLen);}//关键在这里，可以看出来，是new了一个新的字符串return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);}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);}//这里使用了copyOfRange方法，看下面的方法this.value = Arrays.copyOfRange(value, offset, offset+count);}public static char[] copyOfRange(char[] original, int from, int to) {int newLength = to - from;if (newLength < 0)throw new IllegalArgumentException(from + " > " + to);//内部创建了一个新的数组来存储旧的内容char[] copy = new char[newLength];System.arraycopy(original, from, copy, 0,Math.min(original.length - from, newLength));return copy;}

2、concat

可以看到内部也是使用了new String的方法来创建一个新的 String 字符串，原理就不多解释了

 public String concat(String str) {int otherLen = str.length();if (otherLen == 0) {return this;}int len = value.length;char buf[] = Arrays.copyOf(value, len + otherLen);str.getChars(buf, len);return new String(buf, true);}

2. final类的设计

发现该类、类中所有属性都是 final 的，final 的一些基本知识可以看这里 浅谈final

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

关于这个知识，先给个视频的链接：final 原理，在《Java并发编程的艺术》中也有关于 final 类的介绍，会单独写一篇文章来介绍 final 的内存语义。

关于 final 变量的写：简单来说就是也会添加一层内存屏障阻止其他线程对于这个变量没有赋值完成前的读。

关于 final 变量的写：看以下代码，从字节码层面来进行分析

public class TestFinal {//两个静态的成员变累static int A = 10;static int B = Short.MAX_VALUE+1;//两个普通的final变累final int a = 20;final int b = Integer.MAX_VALUE;final void test1() {final int c = 30;new Thread(()->{System.out.println(c);}).start();final int d = 30;class Task implements Runnable {@Overridepublic void run() {System.out.println(d);}}new Thread(new Task()).start();}}class UseFinal1 {public void test() {System.out.println(TestFinal.A);   //1System.out.println(TestFinal.B);   //2System.out.println(new TestFinal().a);   //3System.out.println(new TestFinal().b);   //4new TestFinal().test1();}
}class UseFinal2 {public void test() {System.out.println(TestFinal.A);}
}

下面就是字节码层面的对于 1 和 2 的操作

  L0LINENUMBER 33 L0GETSTATIC java/lang/System.out : Ljava/io/PrintStream;//这个实例实际上是把final复制了一份到了栈中，然后在栈里面去获取数值//如果不加final，这个指令就是GETSTATICBIPUSH 10INVOKEVIRTUAL java/io/PrintStream.println (I)VL1LINENUMBER 34 L1GETSTATIC java/lang/System.out : Ljava/io/PrintStream;//读取常量池中的内容，JDK8之后是在堆中了LDC 32768INVOKEVIRTUAL java/io/PrintStream.println (I)V

实际上，上面的字节码体现出来的一个特点就是说 final 修饰的变量是一开始就确定好的，后面无法进行修改，要读的时候可以看到普通的值是复制了一份到栈中去读，而超出最大值是移到了堆中。

3. 享元模式

定义：. 当需要重用数量有限的同一类对象时，就可以使用享元模式

实际上就是使用已经创建好的对象，而不是使用新对象。

1. 体现

• 在JDK中 Boolean，Byte，Short，Integer，Long，Character 等包装类提供了 valueOf 方法

  • 注意：valueOf方法中，不是全部范围的数值都是使用的重用，而是在一定范围才会用到，我们可以看看源码，以 Short.valueOf() 为例可以看到在 [-128 ~ 127 ] 之间才会重用，而超出这个对象就不可重用。

  • Byte, Short, Long 缓存的范围都是 -128 - 127

  • Character 缓存的范围是 0 - 127

  • Integer的默认范围是 -128~127，最小值不能变，但最大值可以通过调整虚拟机参数 -"Djava.lang.Integer.IntegerCache.high "来改变

  • Boolean 缓存了 TRUE 和 FALSE

  • 至于为什么都是 -128 - 127，可能是在这个区间使用的次数比较多吧，按写项目的思维，都是把一些常用的缓存起来的

• String 串池

• BigDecimal BigInteger（内部也是使用了 new 的方式创建一个新的，保护旧的）

但是：不可变类的线程安全是指单个作用的时候是线程安全的，组合起来或者调用多次方法就不是线程安全的了。比如在测试 BigDecimal 的时候，使用了一个原子引用类保护起来的。

2.自定义一个连接池

1. 参数设计和构造方法

    //1. 指定连接池大小private final int poolSize;//2. 连接对象的数组private Connection[] connections;//3. 连接状态数组 0 空闲 1 繁忙private AtomicIntegerArray status;//4. 构造方法对属性进行初始化public Pool(int poolSize){this.poolSize = poolSize;this.connections = new Connection[poolSize];this.status = new AtomicIntegerArray(new int[poolSize]);for(int i = 0; i < poolSize; i++){connections[i] = new MorkConnection("连接-" + (i + 1));}}

2. 取连接的方法

使用wait - notifyAll 的方式，当一个线程获取不到连接时就使用 wait 等待，实际上这里使用 park - unpark 更好，因为使用 wait - notifyAll 可能出现在 wait 之前就进行了 notifyAll 的情况

//5. 借连接public Connection borrow(){while(true){for(int i = 0; i < poolSize; i++){//获取了空闲连接if(status.get(i) == 0){//取出一个连接就把对应下标的状态设置为 1if(status.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();}}}}

3. 归还连接

归还连接的时候不需要 CAS 操作，因为connections[i] == connection这个 if 判断为真就说明了当前的线程的连接是对应了一个下标的，其他线程有其他的连接，是不同的，所以不会有两个线程进入这里来设置 i 为 0；

//6. 归还连接
public void free(Connection connection){for(int i = 0; i < poolSize; i++){if(connections[i] == connection){status.set(i, 0);synchronized (this){log.debug("free:{}", connection);this.notifyAll();}break;}}
}

4. 全部代码

@Slf4j
class Pool{//1. 指定连接池大小private final int poolSize;//2. 连接对象的数组private Connection[] connections;//3. 连接状态数组 0 空闲 1 繁忙private AtomicIntegerArray status;//4. 构造方法对属性进行初始化public Pool(int poolSize){this.poolSize = poolSize;this.connections = new Connection[poolSize];this.status = new AtomicIntegerArray(new int[poolSize]);for(int i = 0; i < poolSize; i++){connections[i] = new MorkConnection("连接-" + (i + 1));}}//5. 借连接public Connection borrow(){while(true){for(int i = 0; i < poolSize; i++){//获取了空闲连接if(status.get(i) == 0){if(status.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 connection){for(int i = 0; i < poolSize; i++){if(connections[i] == connection){status.set(i, 0);synchronized (this){log.debug("free:{}", connection);this.notifyAll();}break;}}}
}//连接，我们只需要用来作为连接，里面的方法不需要重写
class MorkConnection implements Connection{private String name;public MorkConnection(String name) {this.name = name;}@Overridepublic String toString() {return "MorkConnection{" +"name='" + name + '\'' +'}';}//省略一大堆重写的方法
}

5. 测试结果

Poolsize pool = new Poolsize(2);for(int i = 0; i < 5; i ++){new Thread(()->{Connection connection = pool.borrow();try {Thread.sleep(new Random().nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();}finally {pool.free(connection);}}).start();}

//1。 
15:29:13.226 [Thread-1] DEBUG cn.itcast.n7.Poolsize - wait...
15:29:13.226 [Thread-2] DEBUG cn.itcast.n7.Poolsize - borrow:MorkConnection{name='连接-2'}
15:29:13.231 [Thread-4] DEBUG cn.itcast.n7.Poolsize - wait...
15:29:13.231 [Thread-3] DEBUG cn.itcast.n7.Poolsize - wait...
15:29:13.226 [Thread-0] DEBUG cn.itcast.n7.Poolsize - borrow:MorkConnection{name='连接-1'}
上面是线程 2 和线程 0 获取到了锁，然后其他三个线程没有获取到，就在等待//2. 
//线程 0 释放锁
15:29:13.552 [Thread-0] DEBUG cn.itcast.n7.Poolsize - free:MorkConnection{name='连接-1'}
//线程 3 获取到锁获取到锁
15:29:13.552 [Thread-3] DEBUG cn.itcast.n7.Poolsize - borrow:MorkConnection{name='连接-1'}
15:29:13.552 [Thread-4] DEBUG cn.itcast.n7.Poolsize - wait...
15:29:13.552 [Thread-1] DEBUG cn.itcast.n7.Poolsize - wait...
//此时线程4和线程1还是在等待//3. 
//线程2释放了锁
15:29:13.929 [Thread-2] DEBUG cn.itcast.n7.Poolsize - free:MorkConnection{name='连接-2'}
15:29:13.929 [Thread-4] DEBUG cn.itcast.n7.Poolsize - wait...
//线程1获取了锁
15:29:13.929 [Thread-1] DEBUG cn.itcast.n7.Poolsize - borrow:MorkConnection{name='连接-2'}
//此时线程4还是在等待//4. 
//线程1释放锁
15:29:14.348 [Thread-1] DEBUG cn.itcast.n7.Poolsize - free:MorkConnection{name='连接-2'}
//线程 4 获取到锁
15:29:14.348 [Thread-4] DEBUG cn.itcast.n7.Poolsize - borrow:MorkConnection{name='连接-2'}
//最后线程3释放锁
15:29:14.355 [Thread-3] DEBUG cn.itcast.n7.Poolsize - free:MorkConnection{name='连接-1'}
//线程4释放锁
15:29:14.797 [Thread-4] DEBUG cn.itcast.n7.Poolsize - free:MorkConnection{name='连接-2'}Process finished with exit code 0

如有错误，欢迎指出！！！