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

蔚落 2024-04-08 10:40 85阅读 0赞

#### 文章目录 ####

*   *  一、日期转换问题
     *  二、不可变设计
     *   *  1、final的使用
         *  2、保护性拷贝
         *  3、模式之享元（重要）
         *  4、原理之final（重要）
     *  三、无状态
     *  四、本章小结

> **本章内容**
> 
>  *  不可变类的使用
>  *  不可变类设计
>  *  无状态类设计

### 一、日期转换问题 ###

**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或者出现不正确的日期解析结果，例如：  
> ![在这里插入图片描述][ab4fa6caaf524ddb9e81e3959a0aaacb.png]

**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的文档：  
> ![在这里插入图片描述][bda17a47a69e46ef86f0b14b36eb6e30.png]

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

### 二、不可变设计 ###

> 另一个大家更为熟悉的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;
    }

> 字节码：  
> ![在这里插入图片描述][56c1b00142dd4218a503210b5ec0757f.png]

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

**2、获取final变量的原理**

### 三、无状态 ###

> 在web阶段学习时，设计Servlet时为了保证其线程安全，都会有这样的建议，不要为Servlet设置成员变量，这种没有任何成员变量的类是线程安全的。
> 
>  *  因为成员变量保存的数据也可以称为状态信息，因此没有成员变量就称之为【无状态】

### 四、本章小结 ###

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

[ab4fa6caaf524ddb9e81e3959a0aaacb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5363db1c773142fa9eefac380e69ee39.png
[bda17a47a69e46ef86f0b14b36eb6e30.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/75568bacb3b34883ad13564d1ea21b12.png
[56c1b00142dd4218a503210b5ec0757f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5526c56757ce45e3b143716685c375f9.png