Java并发编程(八) : 不可变对象设计(String保护性拷贝)、final的使用、享元模式

2021-01-17 12:07:56 58 收藏
分类专栏： Java并发编程 文章标签： String不可变设计 final的含义 享元设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37989980/article/details/111825523
版权

一、 不可变类设计 String

如果一个对象在不能够修改其内部状态（属性），那么它就是线程安全的，因为不存在并发修改

  • 类用 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或者出现不正确的日期解析结果，例如：
java.lang.NumberFormatException: For input string: ".19511951E4"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:578)
	at java.lang.Long.parseLong(Long.java:631)
	at java.text.DigitList.getLong(DigitList.java:195)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
	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 com.guizy.cas.Test2.lambda$main$0(Test2.java:20)
	at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: For input string: ""
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Long.parseLong(Long.java:601)
	at java.lang.Long.parseLong(Long.java:631)
	at java.text.DigitList.getLong(DigitList.java:195)
	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
	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 com.guizy.cas.Test2.lambda$main$0(Test2.java:20)
	at java.lang.Thread.run(Thread.java:748)
21:22:13.526 guizy.Test2 [Thread-8] - Sat Apr 21 00:00:00 CST 1951
21:22:13.525 guizy.Test2 [Thread-0] - Wed Feb 21 00:00:00 CST 1951
  • 思路: 使用同步锁
    这样虽能解决问题，但带来的是性能上的损失，并不算很好, 加锁耗性能
@Slf4j(topic = "guizy.Test2")
public class Test2 {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (sdf) {
                    try {
                        log.debug("{}", sdf.parse("2020-12-29"));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

21:24:31.989 guizy.Test2 [Thread-0] - Sat Apr 29 00:00:00 CST 2020
21:24:32.000 guizy.Test2 [Thread-9] - Sat Apr 29 00:00:00 CST 2020
21:24:32.000 guizy.Test2 [Thread-8] - Sat Apr 29 00:00:00 CST 2020
21:24:32.000 guizy.Test2 [Thread-7] - Sat Apr 29 00:00:00 CST 2020
21:24:32.001 guizy.Test2 [Thread-6] - Sat Apr 29 00:00:00 CST 2020
21:24:32.001 guizy.Test2 [Thread-5] - Sat Apr 29 00:00:00 CST 2020
21:24:32.001 guizy.Test2 [Thread-4] - Sat Apr 29 00:00:00 CST 2020
21:24:32.002 guizy.Test2 [Thread-3] - Sat Apr 29 00:00:00 CST 2020
21:24:32.002 guizy.Test2 [Thread-2] - Sat Apr 29 00:00:00 CST 2020
21:24:32.002 guizy.Test2 [Thread-1] - Sat Apr 29 00:00:00 CST 2020
  • 思路 - 使用JD8中的 不可变日期格式化类
  • 如果一个对象在不能够修改其内部状态（属性），那么它就是线程安全的，因为不存在并发修改啊！这样的对象在Java 中有很多，例如在 Java 8 后，提供了一个新的日期格式化类：
@Slf4j(topic = "guizy.Test2")
public class Test2 {
    public static void main(String[] args) {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                TemporalAccessor date = dtf.parse("2020-12-29");
                log.debug("{}", date);
            }).start();
        }
    }
}

21:38:54.842 guizy.Test2 [Thread-0] - {},ISO resolved to 2020-12-29
21:38:54.843 guizy.Test2 [Thread-1] - {},ISO resolved to 2020-12-29
21:38:54.842 guizy.Test2 [Thread-8] - {},ISO resolved to 2020-12-29
21:38:54.842 guizy.Test2 [Thread-9] - {},ISO resolved to 2020-12-29
21:38:54.842 guizy.Test2 [Thread-2] - {},ISO resolved to 2020-12-29
21:38:54.843 guizy.Test2 [Thread-4] - {},ISO resolved to 2020-12-29
21:38:54.843 guizy.Test2 [Thread-3] - {},ISO resolved to 2020-12-29
21:38:54.842 guizy.Test2 [Thread-7] - {},ISO resolved to 2020-12-29
21:38:54.842 guizy.Test2 [Thread-6] - {},ISO resolved to 2020-12-29
21:38:54.842 guizy.Test2 [Thread-5] - {},ISO resolved to 2020-12-29

可以看 DateTimeFormatter 的文档：
在这里插入图片描述

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

2、final 的使用

  • Integer、Double、String、DateTimeFormatter以及基本类型包装类, 都是使用final来修饰的
  • 另一个大家更为熟悉的 String 类也是不可变的，以它为例，说明一下不可变类设计的要素
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];	// 在JDK9 使用了byte[] 数组
    /** Cache the hash code for the string */
    private int hash; // Default to 0
    // ...
}
  • 发现该类、类中所有属性都是 final 的，属性用 final 修饰保证了该属性是只读的，不能修改，类用 final 修饰保证了该类中的方法不能被覆盖，防止子类无意间破坏不可变性。
2.1、保护性拷贝
  • 使用字符串时，也有一些跟修改相关的方法啊，比如substring、replace 等，那么下面就看一看这些方法是 如何实现的，就以 substring 为例：
public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    // 上面是一些校验，下面才是真正的创建新的String对象
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}
  • 发现其方法最后是调用String 的构造方法创建了一个新字符串，再进入这个构造看看，是否对 final char[] value 做出了修改：结果发现也没有，构造新字符串对象时，会生成新的 char[] value，对内容进行复制。
  • 这种通过创建副本对象来避免共享的手段称之为【保护性拷贝（defensive copy）】
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;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    // 上面是一些安全性的校验，下面是给String对象的value赋值，新创建了一个数组来保存String对象的值
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}
2.2、final原理
  • 设置 final 变量的原理
    • 理解了 volatile 原理 (读写屏障)，再对比 final 的实现就比较简单了
public class 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: retu
  • 发现 final 变量的赋值也会通过 putfield 指令来完成，同样在这条指令之后也会加入写屏障，保证在其它线程读到它的值时不会出现为 0 的情况。

3、享元设计模式

  • 简介定义英文名称：Flyweight pattern, 重用数量有限的同一类对象。
    • 结构型模式
  • 享元模式的体现
    • 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
  • Boolean 缓存了 TRUE 和 FALSE
  • Integer的默认范围是 -128~127，最小值不能变，但最大值可以通过调整虚拟机参数 "-Djava.lang.Integer.IntegerCache.high "来改变
  • 2、String 串池
  • 3、BigDecimal, BigInteger

eg :
在这里插入图片描述

4、实现一个简单的连接池

  • 例如：一个线上商城应用，QPS 达到数千，如果每次都重新创建和关闭数据库连接，性能会受到极大影响。 这时预先创建好一批连接，放入连接池。一次请求到达后，从连接池获取连接，使用完毕后再还回连接池，这样既节约了连接的创建和关闭时间，也实现了连接的重用，不至于让庞大的连接数压垮数据库。
/**
 * Description: 简易连接池
 *
 * @author guizy
 * @date 2020/12/29 21:21
 */
public class Test2 {
    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 = "guizy.Pool")
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]);//使用AtomicIntegerArray保证states的线程安全
        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)) {//使用compareAndSet保证线程安全
                        log.debug("borrow {}", connections[i]);
                        return connections[i];
                    }
                }
            }
            // 如果没有空闲连接，当前线程进入等待, 如果不写这个synchronized,其他线程不会进行等待, 
            // 一直在上面while(true), 空转, 消耗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) {
                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 + '\'' +
                '}';
    }
    
    // Connection 实现方法略
}

22:01:07.000 guizy.Pool [Thread-2] - wait...
22:01:07.000 guizy.Pool [Thread-0] - borrow MockConnection{name='连接1'}
22:01:07.005 guizy.Pool [Thread-4] - wait...
22:01:07.000 guizy.Pool [Thread-1] - borrow MockConnection{name='连接2'}
22:01:07.006 guizy.Pool [Thread-3] - wait...
22:01:07.099 guizy.Pool [Thread-0] - free MockConnection{name='连接1'}
22:01:07.099 guizy.Pool [Thread-2] - wait...
22:01:07.099 guizy.Pool [Thread-3] - borrow MockConnection{name='连接1'}
22:01:07.099 guizy.Pool [Thread-4] - wait...
22:01:07.581 guizy.Pool [Thread-3] - free MockConnection{name='连接1'}
22:01:07.582 guizy.Pool [Thread-2] - borrow MockConnection{name='连接1'}
22:01:07.582 guizy.Pool [Thread-4] - wait...
22:01:07.617 guizy.Pool [Thread-1] - free MockConnection{name='连接2'}
22:01:07.618 guizy.Pool [Thread-4] - borrow MockConnection{name='连接2'}
22:01:07.955 guizy.Pool [Thread-4] - free MockConnection{name='连接2'}
22:01:08.552 guizy.Pool [Thread-2] - free MockConnection{name='连接1'}

在这里插入图片描述

已标记关键词 清除标记
Java面试基础
ggs_27的博客
10-13 460
文章目录1. Java概述1.1 何为编程1.1.1 什么是Java1.1.2 jdk1.5之后的三大版本1.1.3 JVM、JRE和JDK的关系1.1.4 什么是跨平台性？原理是什么1.1.5 Java语言有哪些特点1.1.6 什么是字节码？采用字节码的最大好处是什么1.1.7 什么是Java程序的主类？应用程序和小程序的主类有何不同？1.1.8 Java应用程序与小程序之间有那些差别？1.1.9 Java和C++的区别1.1.10 Oracle JDK 和 OpenJDK 的对比（感觉有点偏）2.基础语
表情包
插入表情
还能输入1000个字符
相关推荐
Java基础知识面试题（2020最新版）
ThinkWon的博客
02-19 71万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
Java并发学习笔记（六）：不可变、final、保护性拷贝、享元模式、final原理、无状态
Miracle42的博客
06-01 151
不可变 一、 日期转换的问题 1、引入 下面的代码在运行时，由于 SimpleDateFormat 不是线程安全的 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); for (int i = 0; i < 10; i++) { new Thread(() -> { try { System.out.println(sdf.parse("1951-04-21"));
2020最新Java面试题，常见面试题及答案汇总
Java笔记
01-27 16万+
发现网上很多Java面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别？ JDK：Java Development Kit 的简称，java 开发工具包，提供了 java 的开发环境和运行环境。 JRE：Java Runtime Environment 的简称，java 运行环境，为 jav...
Java并发编程（六）不可改变对象
u014088294的专栏
08-16 2538
6. 不可改变对象如果一个对象在创建后不可改变，那么就称之为不可改变对象。基于不可变对象被广泛接受为创建简单、可靠代码的有效策略。不可变对象在并发程序中显得尤为重要。由于它们不能改变，所以他们不会在线程干扰中出现错误，并且不会出现非一致性状态。开发者并不太原因使用不可变对象，他们担心创建对象的开销比更新一个现有对象的开销大。创建对象的开销经常被夸大，并且可以被不可变对象带来的效率弥补。这包括由于垃圾
String类不可变以及不可变类总结
学习记录
10-01 5880
String类在java中是immutable(不可变)，因为它被关键字final修饰。当String实例创建时就会被初始化，并且以后无法修改实例信息。String类是工程师精心设计的艺术品。 一、String为什么不可变？ 要了解String类创建的实例为什么不可变，首先要知道final关键字的作用：final的意思是“最终，最后”。final关键字可以修饰类、方法...
java 不可修改对象_Java并发编程（六）不可改变对象
weixin_28961225的博客
02-13 12
6. 不可改变对象如果一个对象在创建后不可改变，那么就称之为不可改变对象。基于不可变对象被广泛接受为创建简单、可靠代码的有效策略。不可变对象在并发程序中显得尤为重要。由于它们不能改变，所以他们不会在线程干扰中出现错误，并且不会出现非一致性状态。开发者并不太原因使用不可变对象，他们担心创建对象的开销比更新一个现有对象的开销大。创建对象的开销经常被夸大，并且可以被不可变对象带来的效率弥补。这包括由于垃...
java并发学习33：不可变对象
八十岁老将的博客
01-28 6
1、不可变对象使用 DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); for (inti=0; i<10; i++) { new Thread(() -> { LocalDate date = dtf.parse("2018-10-01", LocalDate::from); log.debug("{}", date); }).start(); } 2、设计
JAVA - 可变对象与不可变对象
bupa900318的博客
06-14 4781
不可变对象在并发程序中比较有用，由于其状态无法改变，因此无法被线程的干扰损坏或者被视为不一致状态。基本概念   *不可变对象(Immutable Objects)即对象一旦被创建它的状态（对象的数据，也即对象属性值）就不能改变，任何对它的改变都应该产生一个新的对象。* 可变对象(Mutable Objects)：相对于不可变类，可变类创建实例后可以改变其成员变量值，开发中创建的大部分类都属于可变类...
《java并发编程实战》 第四章 对象如何组合
乌鸦大大
01-20 543
《java并发编程实战笔记》第四章 对象的组合如何设计线程安全的类----思想层面 第四章 对象的组合 为什么出现对象的组合？在前三章中，我们并不希望对每一次内存访问都进行确保程序是线程安全的，而是希望将一些现有的线程安全组件组合成更为规模大的组件。对象的组合模式能将一个类更容易成为线程安全的。书中原话，通过使用封装技术，可以使得在不对整个程序进行分析情况下，就可以判断一个类是否线程安全。(这么强...
并发编程面试题（2020最新版）
ThinkWon的博客
03-14 19万+
文章目录基础知识并发编程的优缺点为什么要使用并发编程（并发编程的优点）并发编程有什么缺点并发编程三要素是什么？在 Java 程序中怎么保证多线程的运行安全？并行和并发有什么区别？什么是多线程，多线程的优劣？线程和进程区别什么是线程和进程?进程与线程的区别什么是上下文切换?守护线程和用户线程有什么区别呢？如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？什么是线程死锁形成死锁的...
Java集合面试题
木村的博客
06-25 1万+
Java集合面试题 Java 集合框架的基础接口有哪些？ Collection ，为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java 平台不提供这个接口任何直接的实现。 Set ，是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。 List ，是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态...
Java并发编程最佳实例详解系列
loveyouluobin的博客
04-26 8777
Java并发编程最佳实例详解系列: Java并发编程（一）线程定义、状态和属性 Java并发编程（一）线程定义、状态和属性 线程是指程序在执行过程中，能够执行程序代码的一个执行单元。在java语言中，线程有四种状态：运行 、就绪、挂起和结束。 进程是指一段正在执行的程序。而线程有时也被成为轻量级的进程，他是程序执行的最小单元，一个进程可以拥有多个线程，各个线程之间共享程序的内功空间（代码...
不可变对象（Immutable Objects）in Java
capsM's Blog
11-10 854
本文主要阐述以下观点： 1.值类型与引用类型的定义与区别； 2.不可变对象与可变对象的定义与区别； 3.不可变对象的优点与缺点； 4.String类为什么是不可变的； 5.怎样声明不可变对象（包括变量和类）；
Java面试题全集（上）
骆昊的技术专栏
04-08 129万+
2013年年底的时候，我看到了网上流传的一个叫做《Java面试题大全》的东西，认真的阅读了以后发现里面的很多题目是重复且没有价值的题目，还有不少的参考答案也是错误的，于是我花了半个月时间对这个所谓的《Java面试大全》进行了全面的修订并重新发布在我的CSDN博客。
Java并发编程-对象共享
藏经阁
04-27 330
本文将介绍Java并发编程中的对象共享问题和解决办法。 java并发访问共享数据的三种方式： 1、synchronized 对共享变量进行变更的方法、代码块 使用synchronized关键字（或者Lock）。 2、对共享变量使用volatile关键字。 3、使用Atomic包中的原子性操作类。 ...
Java并发指南4：Java中的锁 Lock和synchronized
程序员书单
03-08 7399
Java中的锁机制及Lock类 锁的释放-获取建立的happens before 关系 锁是java并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。 下面是锁释放-获取的示例代码： class MonitorExample { int a = 0; public synchronized void wr...
带你读懂《Java并发编程》：第3章 助于线程安全的三剑客：final&valitale&线程封闭...
Diligence is the mother of success.
12-13 32
点击上方蓝字关注我们我们简要的回顾前文：《第1章 多线程安全性与风险》介绍了并发编程，在维护难度、性能以及活跃性三个方面，所带来的风险与优势；《第2章影响线程安全性的原子性和加锁机制》...
带你读懂《Java并发编程》：第3章 助于线程安全的三剑客：final & volatile & 线程封闭...
Diligence is the mother of success.
12-14 16
点击上方蓝字关注我们我们简要的回顾前文：《第1章 多线程安全性与风险》介绍了并发编程，在维护难度、性能以及活跃性三个方面，所带来的风险与优势；《第2章影响线程安全性的原子性和加锁机制》...
《Java并发编程实战》- 个人阅读总结（一）
追求自由的码砖人
03-06 9596
背景最近想更深入了解下Java多线程相关的知识，对Java多线程有一个全面的认识，所以想找一本Java多线程相关的书籍来阅读，最后我选择了《Java并发编程实战》这本个人认为还算相当不错，至于为什么选择它，下面有介绍。书的介绍中文书名：《Java并发编程实战》 英文书名：《Java Concurrency in Practice》 作者：Brian Goetz / Tim Peierls / J
©️2020 CSDN 皮肤主题: 撸撸猫 设计师:C马雯娟 返回首页