本章内容
- 不可变类的使用
- 不可变类设计
- 无状态类设计
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 (ParseException e) {
e.printStackTrace();
}
}).start();
}
有很大几率出现java.lang.NumberFormatException
Exception in thread "Thread-1" Exception in thread "Thread-5" Exception in thread "Thread-2" Exception in thread "Thread-3" 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:2056)
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 notchange.Test1.lambda$main$0(Test1.java:19)
at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: empty String
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1842)
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:2056)
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 notchange.Test1.lambda$main$0(Test1.java:19)
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:2056)
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 notchange.Test1.lambda$main$0(Test1.java:19)
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:2056)
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 notchange.Test1.lambda$main$0(Test1.java:19)
at java.lang.Thread.run(Thread.java:748)
2022/03/13-01:00:11.983 [Thread-8] c.Test1 - Sat Apr 21 00:00:00 CST 1951
2022/03/13-01:00:11.983 [Thread-9] c.Test1 - Sat Apr 21 00:00:00 CST 1951
2022/03/13-01:00:11.983 [Thread-6] c.Test1 - Fri Aug 21 00:00:00 CST 176769542
2022/03/13-01:00:11.983 [Thread-7] c.Test1 - Sat Mar 31 00:00:00 CST 1951
2022/03/13-01:00:11.983 [Thread-4] c.Test1 - Fri Aug 21 00:00:00 CST 176769542
2022/03/13-01:00:11.983 [Thread-0] c.Test1 - Fri Aug 21 00:00:00 CST 176769542
思路-同步锁
这样虽然能解决问题,但带来的是性能的损失,并不算好:
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 (ParseException e) {
e.printStackTrace();
}
}
}).start();
}
思路-不可变
如果对象在一个不能修改其内部状态(属性),那么它就是线程安全的,因为不存在并发修改,这样的对象在java中有很多,例如java8之后,提供了一个新的日期格式化类:
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
new Thread(() -> {
log.debug("{}", dtf.parse("1951-04-21"));
}).start();
}
可以看DateTimeFormatter
* @implSpec
* This class is immutable and thread-safe.
2、不可变设计
另一个大家更为熟悉的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
// ...
}
final的使用
发现该类,类中所有属性都是final的
- 属性用final修饰保证了该属性是只读的,不能修改
- 类用final修饰保证了该类中的方法不能覆盖,防止子类无意间破坏不可变性
保护性拷贝
但有同学会说,使用字符串时,也有一些跟修改相关的方法啊,比如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、模式之享元
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
2、体现
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.IntegerCache.high
来改变- Boolean缓存了TRUE和FALSE
2.2 String 串池
2.3 Bigdecimal BigInteger
3、DIY
例如:一个线上商城应用,QPS达到数千,如果每次都重新传建和关闭数据库连接,性能会受到极大影响。这是预先创建好一批连接,放入连接池。一次请求到达后,从连接池获取连接,使用完毕后再还给连接池,这样既节约了连接的创建和关闭时间,也实现了连接的重用,不至于让庞大的连接数压垮数据库。
@Slf4j(topic = "c.Pool")
public class Pool {
// 1.连接池大小
private final int poolSize;
// 2.连接对象数组
private Connection[] connections;
// 连接状态数组 0表示空闲,1表示繁忙
private AtomicIntegerArray states;
// 4.构造方法初始化
public Pool(int poolSize) {
this.poolSize = poolSize;
this.connections = new Connection[poolSize];
this.states = new AtomicIntegerArray(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 {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
// 6.归还连接
public void free(Connection conn) {
for (int i = 0; i < poolSize; i++) {
if (conn == connections[i]) {
states.set(i, 0);
log.debug("free {}", conn);
synchronized (this) {
this.notifyAll();
}
break;
}
}
}
}
class MockConnection implements Connection {
String name;
public MockConnection(String name) {
this.name = name;
}
@Override
public String toString() {
return "MockConnection{" +
"name='" + name + '\'' +
'}';
}
}
interface Connection {
}
测试
Pool pool = new Pool(2);
for (int i = 0; i < 5; i++) {
new Thread(() -> {
Connection connection = pool.borrow();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
pool.free(connection);
}).start();
}
输出
2022/03/13-01:46:50.896 [Thread-1] c.Pool - borrow MockConnection{name='连接2'}
2022/03/13-01:46:50.896 [Thread-0] c.Pool - borrow MockConnection{name='连接1'}
2022/03/13-01:46:51.903 [Thread-1] c.Pool - free MockConnection{name='连接2'}
2022/03/13-01:46:51.903 [Thread-0] c.Pool - free MockConnection{name='连接1'}
2022/03/13-01:46:51.903 [Thread-4] c.Pool - borrow MockConnection{name='连接1'}
2022/03/13-01:46:51.903 [Thread-3] c.Pool - borrow MockConnection{name='连接2'}
2022/03/13-01:46:52.908 [Thread-4] c.Pool - free MockConnection{name='连接1'}
2022/03/13-01:46:52.908 [Thread-3] c.Pool - free MockConnection{name='连接2'}
2022/03/13-01:46:52.908 [Thread-2] c.Pool - borrow MockConnection{name='连接1'}
2022/03/13-01:46:53.918 [Thread-2] c.Pool - free MockConnection{name='连接1'}
以上实现没有考虑:
- 连接池的动态增长与收缩
- 连接保活(可用性检测)
- 等待超时处理
- 分布式hash
对于关系型数据库,有比较成熟的连接池实现,例如c3p0,druid等 ,对于更通用的对象池,可以考虑apache commons pool,例如redis连接池可以参考jedis中关于连接池的实现
原理之final
1、设置final变量的原理
理解了volatile原理,再对比final的实现就比较简单了
public vlass TestFinal{
final int a = 20;
}
字节码
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 20
7: putfield #2 // Field a:I
<-- 写屏障
10: return
发现final变量的赋值也会通过putfield指令完成,同样在这条指令之后也会加入写屏障,保证其他线程读到它的值时不会出现0的情况
2、获取final变量的原理
5、无状态
在web学习阶段时,设计Servlet时为了保证其线程安全,都会有这样的建议,不要为Servlet设置成员变量,这种没有任何成员变量的类是线程安全的
因为成员变量保存的数据也可以称为状态信息,因此没有成员变量就称之为【无状态】
本章小结
- 不可变类使用
- 不可变类设计
- 原理方面
- final
- 模式方面
- 享元模式