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

最新推荐文章于 2024-08-03 17:05:14 发布

Why。

最新推荐文章于 2024-08-03 17:05:14 发布

阅读量1.3k

点赞数 17

分类专栏： JUC 文章标签： java 前端服务器

本文链接：https://blog.csdn.net/qq_44989062/article/details/138345005

版权

JUC 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

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-safe
        DateTimeFormatter 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 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 自定义连接池

例如：一个线上商城应用，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. 连接池大小 假设大小固定+final
    private 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) {
				//归还连接的线程 就是 连接的持有者 不会发送竞争 不需要compareAndSet
                states.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;
    }

    @Override
    public String toString() {
        return "MockConnection{" +
                "name='" + name + '\'' +
                '}';
    }
    //......
}

以上实现没有考虑：