Java并发：五种线程安全类型、线程安全的实现、枚举类型

Love The Way You Lie 2023-09-28 10:33 58阅读 0赞

## 1. Java中的线程安全 ##

*  Java线程安全：狭义地认为是多线程之间共享数据的访问。
 *  Java语言中各种操作共享的数据有5种类型：不可变、绝对线程安全、相对线程安全、线程兼容、线程独立

## ① 不可变 ##

*  不可变（Immutable） 的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。
 *  只要能正确构建一个不可变对象，该对象永远不会在多个线程之间出现不一致的状态。
 *  多线程环境下，应当尽量使对象成为不可变，来满足线程安全。

**如何实现不可变？**

*  如果共享数据是基本数据类型，使用final关键字对其进行修饰，就可以保证它是不可变的。
 *  如果共享数据是一个对象，要保证对象的行为不会对其状态产生任何影响。
 *  String是不可变的，对其进行substring()、replace()、concat()等操作，返回的是新的String对象，原始的String对象的值不受影响。而如果对StringBuffer或者StringBuilder对象进行substring()、replace()、append()等操作，直接对原对象的值进行改变。
 *  要构建不可变对象，需要将内部状态变量定义为final类型。如java.lang.Integer类中将value定义为final类型。

private final int value;

**常见的不可变的类型：**

*  final关键字修饰的基本数据类型
 *  枚举类型、String类型
 *  常见的包装类型：Short、Integer、Long、Float、Double、Byte、Character等
 *  大数据类型：BigInteger、BigDecimal

> 注意：原子类 AtomicInteger 和 AtomicLong 则是可变的。

对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。

*  通过Collections.unmodifiableMap(map)获的一个不可变的Map类型。
 *  Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。

例如，如果获得的不可变map对象进行put()、remove()、clear()操作，则会抛出UnsupportedOperationException异常。

## ② 绝对线程安全 ##

绝对线程安全的实现，通常需要付出很大的、甚至不切实际的代价。

Java API中提供的线程安全，大多数都不是绝对线程安全。

例如，对于数组集合Vector的操作，如get()、add()、remove()都是有synchronized关键字修饰。有时调用时也需要手动添加同步手段，保证多线程的安全。

下面的代码看似不需要同步，实际运行过程中会报错。

import java.util.Vector;
    
    /**
     * @Author: lucy
     * @Version 1.0
     */
    public class VectorTest {
        public static void main(String[] args) {
            Vector<Integer> vector = new Vector<>();
            while(true){
                for (int i = 0; i < 10; i++) {
                    vector.add(i);
                }
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i = 0; i < vector.size(); i++) {
                            System.out.println("获取vector的第" + i + "个元素: " + vector.get(i));
                        }
                    }
                }).start();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int i=0;i<vector.size();i++){
                            System.out.println("删除vector中的第" + i+"个元素");
                            vector.remove(i);
                        }
                    }
                }).start();
                while (Thread.activeCount()>20)
                    return;
            }
        }
    }

出现ArrayIndexOutOfBoundsException异常，原因：某个线程恰好删除了元素i，使得当前线程无法访问元素i。

Exception in thread "Thread-1109" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 1
     at java.util.Vector.remove(Vector.java:831)
     at VectorTest$2.run(VectorTest.java:28)
     at java.lang.Thread.run(Thread.java:745)

需要将对元素的get和remove构造成同步代码块：

synchronized (vector){
        for (int i = 0; i < vector.size(); i++) {
            System.out.println("获取vector的第" + i + "个元素: " + vector.get(i));
        }
    }
    synchronized (vector){
        for (int i=0;i<vector.size();i++){
            System.out.println("删除vector中的第" + i+"个元素");
            vector.remove(i);
        }
    }

## ③ 相对线程安全 ##

*  相对线程安全需要保证对该对象的单个操作是线程安全的，在必要的时候可以使用同步措施实现线程安全。
 *  大部分的线程安全类都属于相对线程安全，如Java容器中的Vector、HashTable、通过Collections.synchronizedXXX()方法包装的集合。

## ④ 线程兼容 ##

*  Java中大部分的类都是线程兼容的，通过添加同步措施，可以保证在多线程环境中安全使用这些类的对象。
 *  如常见的ArrayList、HashTableMap都是线程兼容的。

## ⑤ 线程对立 ##

*  线程对立是指：无法通过添加同步措施，实现多线程中的安全使用。
 *  线程对立的常见操作有：Thread类的suspend()和resume()（已经被JDK声明废除），System.setIn()和System.setOut()等。

## 2. Java的枚举类型 ##

通过enum关键字修饰的数据类型，叫枚举类型。

*  枚举类型的每个元素都有自己的序号，通常从0开始编号。
 *  可以通过values()方法遍历枚举类型，通过name()或者toString()获取枚举类型的名称
 *  通过ordinal()方法获取枚举类型中元素的序号

public class EnumData {
        public static void main(String[] args) {
            for (Family family : Family.values()) {
                System.out.println(family.name() + "：" + family.ordinal());
            }
        }
    }
    
    enum Family {
        GRADMOTHER, GRANDFATHER, MOTHER, FATHER, DAUGHTER, SON;
    }

![b6e75f9aa0e999d830ee187b018faa4b.png][]

可以将枚举类型看做普通的class，在里面定义final类型的成员变量，便可以为枚举类型中的元素赋初值。

要想获取枚举类型中元素实际值，需要为成员变量添加getter方法。

虽然枚举类型的元素有了自己的实际值，但是通过ordinal()方法获取的元素序号不会发生改变。

public class EnumData {
        public static void main(String[] args) {
            for (Family family : Family.values()) {
                System.out.println(family.name() + "：实际值" + family.getValue() +
                        ", 实际序号" + family.ordinal());
            }
        }
    }
    enum Family {
        GRADMOTHER(3), GRANDFATHER(4), MOTHER(1), FATHER(2), DAUGHTER(5), SON(6);
        private final int value;
        Family(int value) {
            this.value = value;
        }
        public int getValue() {
            return value;
        }
    }

![d09a41239d6f41b2f0a4758603009c7c.png][]

## 3. Java线程安全的实现 ##

## ① 互斥同步 ##

互斥同步（Mutex Exclusion & Synchronization）是一种常见的并发正确性保障手段。

*  同步：多个线程并发访问共享数据，保证共享数据同一时刻只被一个（或者一些，使用信号量）线程使用。
 *  互斥：互斥是实现同步的一种手段，主要的互斥实现方式：临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）。

**同步与互斥的关系：**

*  互斥是原因，同步是结果。
 *  同步是目的，互斥是方法。

Java中，最基本的实现互斥同步的手段是synchronized关键字，其次是JUC包中的ReentrantLock。

**关于synchronized关键字：**

*  编译后的同步块，开始处会添加monitorenter指令，结束处或异常处会添加monitorexit指令。
 *  monitorenter和monitorexit指令中都包含一个引用类型的参数，分别指向加锁或解锁的对象。如果是同步代码块，则为synchronized括号中明确指定的对象；如果为普通方法，则为当前实例对象；如果为静态方法，则为类对应的class对象。
 *  JVM执行monitorenter指令时，要先尝试获取锁：如果对象没被锁定或者当前线程已经拥有该对象的锁，则锁计数器加1；否则获取锁失败，进入阻塞状态，等待持有锁的线程释放锁。
 *  JVM执行monitorexit指令时，锁计数器减1，直到计数器的值为0，锁被释放。（synchronized是支持重进入的）
 *  由于阻塞或者唤醒线程都需要从用户态（User Mode）切换到核心态（Kernel Mode），有时锁只会被持有很短的时间，没有必要进行状态转换。可以让线程在阻塞之前先自旋等待一段时间，超时未获取到锁才进入阻塞状态，这样可以避免频繁的切入到核心态。其实，就是后面自旋锁的思想。

**关于ReentrantLock：**

*  与synchronized关键字相比，它是API层面的互斥锁（lock()、unlock()、try...finally)。
 *  与synchronized关键字相比，具有可中断、支持公平与非公平性、可绑定多个Condition对象的高级功能。
 *  由于synchronized关键字被优化，二者的性能差异并不是很大，如果不是想使用ReentrantLock的高级功能，优先考虑使用synchronized关键字。

## ② 非阻塞同步 ##

## （1）CAS概述 ##

互斥同步最大的性能问题是线程的阻塞和唤醒，因此又叫阻塞同步。

互斥同步采用悲观并发策略：

*  多线程并发访问共享数据时，总是认为只要不加正确的同步措施，肯定会出现问题。
 *  无论共享数据是否存在竞争，都会执行加锁、用户态和心态的切换、维护锁计数器、检查是否有被阻塞的线程需要唤醒等操作。

随着硬件指令集的发展，我们可以采用基于冲突检测的乐观并发策略：

*  先进行操作，如果不存在冲突（即没有其他线程争用共享数据），则操作成功。
 *  如果有其他线程争用共享数据，产生了冲突，使用其他的补偿措施。
 *  常见的补偿措施：不断尝试，直到成功为止，比如循环的CAS操作。

乐观并发策略的许多实现都不需要将线程阻塞，这种同步操作叫做非阻塞同步。

非阻塞同步依靠的硬件指令集：前三条是比较久远的指令，后两条是现代处理器新增的。

*  测试和设置（Test and Set)
 *  获取并增加（Fetch and Increment）
 *  交换（Swap）
 *  比较并交换（Compare and Swap，即CAS）
 *  加载链接/条件存储（Load Linked/ Store Conditional，即LL/SC）

**什么是CAS？**

*  CAS，即Compare and Swap，需要借助处理器的cmpxchg指令完成。
 *  CAS指令需要三个操作数：内存位置V（Java中可以简单的理解为变量的内存地址）、旧的期待值A、新值B。
 *  CAS指令执行时，当且仅当V符合旧的预期值A，处理器才用新值B更新V的值；否则，不执行更新。
 *  不管是否更新V的值，都返回V的旧值，整个处理过程是一个原子操作。

原子操作：所谓的原子操作是指一个或一系列不可被中断的操作。

**Java中的CAS操作：**

*  Java中的CAS操作由sun.misc.Unsafe中的compareAndSwapInt()、compareAndSwapLong()等几个方法包装提供。实际无法调用这些方法，需要采用反射机制才能使用。
 *  在实际的开发过程中，一般通过其他的Java API调用它们，如JUC包原子类中的compareAndSet(expect, update) 、getAndIncrement()等方法。这些方法内部都使用了Unsafe类的CAS操作。
 *  Unsafe类的CAS操作，通过JVM的即时编译器编译后，是一条与平台相关的CAS指令。

除了偏向锁，Java中其他锁的实现方式都是用了循环的CAS操作。学习资料：Java进阶视频资源

## （2）通过循环的CAS实现原子操作 ##

通过++i或者i++可以实现计数器的自增，在多线程环境下，这样使用是非线程安全的。

public class UnsafeCount {
        private int i = 0;
        private static final int THREADS_COUNT = 200;
    
        public static void main(String[] args) {
            Thread[] threads = new Thread[THREADS_COUNT];
            UnsafeCount counter = new UnsafeCount();
            for (int i = 0; i < THREADS_COUNT; i++) {
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 0; j < 10000; j++) {
                            counter.count();
                        }
                    }
                });
                threads[i].start();
            }
            while (Thread.activeCount() > 1) {
                Thread.yield();
            }
            System.out.println("多线程调用计数器i，运行后的值为: " + counter.i);
        }
    
        public void count() {
            i++;
        }
    }

运行以上的代码发现：当线程数量增加，每个线程调用计数器的次数变大时，每次运行的结果是错误且不固定的。

![069df1c7e60dfc05dc3be5e6efddfa0c.png][]

![4de9cb79537b9f219336af347c98c3b1.png][]

为了实现实在一个多线程环境下、线程安全的计数器，需要使用AtomicInteger的原子自增运算。

import java.util.concurrent.atomic.AtomicInteger;
    public class SafeCount {
        private AtomicInteger atomic = new AtomicInteger(0);
        private static final int THREAD_COUNT = 200;
        public static void main(String[] args) {
            SafeCount counter = new SafeCount();
            Thread[] threads = new Thread[THREAD_COUNT];
            for (int i = 0; i < THREAD_COUNT; i++) {
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int j=0;j<10000;j++){
                            counter.count();
                        }
                    }
                });
                threads[i].start();
            }
            while (Thread.activeCount()>1){
                Thread.yield();
            }
            System.out.println("多线程调用线程安全的计数器atomic："+counter.atomic);
        }
        public void count() {
            // 调用compareAnSet方法，使用循环的CAS操作实现计数器的原子自增
            for (; ; ) {
                int expect = atomic.get();
                int curVal = expect + 1;
                if (atomic.compareAndSet(expect, curVal)) {
                    break;
                }
            }
        }
    }

![6a4af1a6588778908561ac40f1ffe653.png][]

与非线程安全的计数器相比，线程安全的计数器有以下特点：

*  将int类型的计数器变量i，更换成具有CAS操作的AtomicInteger类型的计数器变量atomic。
 *  进行自增运算时，通过循环的CAS操作实现atomic的原子自增。
 *  先通过atomic.get()获取expect的值，将expect加一得到新值，然后通过atomic.compareAndSet(expect, curVal)这一方法实现CAS操作。
 *  其中compareAndSet()返回的true或者false，表示此次CAS操作是否成功。如果返回false，则不停地重复执行CAS操作，直到操作成功。

上面的count方法实现的AtomicInteger原子自增，可以只需要调用incrementAndGet()一个方法就能实现。

public void count() {
        // 调用incrementAndGet方法，实现AtomicInteger的原子自增
        atomic.incrementAndGet();
    }

因为incrementAndGet()方法，封装了通过循环的CAS操作实现AtomicInteger原子自增的代码。

public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        return var5;
    }

## （3）CAS操作存在的问题 ##

**1. ABA问题**

*  在执行CAS操作更新共享变量的值时，如果一个值原来是A，被其他线程改成了B，然后又改回成了A。对于该CAS操作来说，它完全感受不到共享变量值的变化。这种操作漏洞称为CAS操作的ABA问题。
 *  解决该问题的思路是，为变量添加版本号，每次更新时版本号递增。这种场景下就成了1A --> 2B --> 3A。CAS操作就能检测到共享变量的ABA问题了。
 *  JUC包中，也提供了相应的带标记的原子引用类AtomicStampedReference来解决ABA问题。
 *  AtomicStampedReference的compareAndSet()方法会首先比较期待的引用是否等于当前引用，然后检查期待的标记是否等于当前标记。如果全部相等，则以原子操作的方式将新的引用和新的标记更新到当前值中。
 *  但是AtomicStampedReference目前比较鸡肋，如果想解决AB问题，可以使用锁。

**2. 循环时间过长，开销大**

循环的CAS操作如果长时间不成功，会给CPU带来非常大的执行开销。

**3. 只能保证一个共享变量的原子操作**

*  只对一个共享变量执行操作时，可以通过循环的CAS操作实现。如果是多个共享变量，循环的CAS操作无法保证操作的原子性。
 *  取巧的操作：将多个共享变量合为一个变量进行CAS操作。JDK1.5开始，提供了AtomicReference类保证引用对象之间的原子性，可以将多个变量放在一个对象中进行CAS操作。

## ③ 无同步方案 ##

同步只是保证共享数据争用时正确性的一种手段，如果不存在共享数据，自然无须任何同步措施。

## （1）栈封闭 ##

多个线程访问同一个方法的局部变量时，不会出现线程安全问题。

因为方法中的局部变量不会逃出该方法而被其他线程访问，因此可以看做JVM栈中数据，属于线程私有。

## （2）可重入代码（Reentrant Code） ##

可重入代码又叫纯代码（Pure Code），可在代码执行的任何时候中断他它，转去执行另外一段代码（包括递归调用它本身），控制权返回后，原来的程序不会出现任何错误。

所有可重入的代码都是线程安全，并非所有线程安全的代码都是可重入的。

可重入代码的共同特征：

*  不依赖存储在堆上的数据和公用的系统资源
 *  用到的状态量都由参数中传入
 *  不调用非可重用的方法

如何判断代码是否具备可重入性？如果一个方法，它的返回结果是可预测的。只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性，当然也就是线程安全的。

## （3）线程本地存储（TLS） ##

线程本地存储（Thread Local Storage）：

*  如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。
 *  如果能保证，我们就可以把共享数据的可见范围限制在同一个线程内。
 *  这样，无须同步也能保证线程之间不出现数据争用的问题。

TLS的重要应用实例：经典的Web交互模型中，一个请求对应一个服务器线程，使得Web服务器应用可以使用。学习资料：Java进阶视频资源

Java中没有关键字可以将一个变量定义为线程所独享，但是Java中创建了java.lang.ThreadLocal类提供线程本地存储功能。

*  每一个线程内部都包含一个ThreadLocalMap对象，该对象将ThreadLocal对象的hashCode值作为key，即ThreadLocal.threadLocalHashCode，将本地线程变量作为value，构成键值对。
 *  ThreadLocal对象是当前线程ThreadLocalMap对象的访问入口，通过threadLocal.set()为本地线程添加独享变量；通过threadLocal.get()获取本地线程独享变量的值。
 *  ThreadLocal、ThreadLocalMap、Thread的关系：Thread对象中包含ThreadLocalMap对象，ThreadLocalMap对象中包含多个键值对，每个键值对的key是ThreadLocal对象的hashCode，value是本地线程变量。

![4ee82cd17e181e9ada16fbde6ca38339.png][]

ThreadLocal的编程实例：

*  想为某个线程添加本地线程变量，必须通过ThreadLocal对象在该线程中进行添加，构造出的键值对自动存入该线程的map中；
 *  想要获取某个线程的本地线程变量，必须在该线程中获取，会自动查询该线程的map，获得ThreadLocal对象对应的value。
 *  通过ThreadLocal对象重复为某个线程添加键值对，会覆盖之前的value。

public class TLS {
        public static void main(String[] args) {
            ThreadLocal<String> threadLocal1 = new ThreadLocal<>();
            ThreadLocal<Integer> threadLocal2 = new ThreadLocal<>();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 设置当前线程的本地线程变量
                    threadLocal1.set("thread1");
                    threadLocal2.set(1);
                    System.out.println(threadLocal1.get() + ": " + threadLocal2.get());
                    // 使用完毕后要删除，避免内存泄露
                    threadLocal1.remove();
                    threadLocal2.remove();
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    threadLocal1.set("thread2");
                    threadLocal2.set(2);
                    System.out.println(threadLocal1.get() + ": " + threadLocal2.get());
                    threadLocal1.remove();
                    threadLocal2.remove();
                }
            });
            thread1.start();
            thread2.start();
            // 没有通过ThreadLocal为主线程添加过本地线程变量，获取到的内容都是null
            System.out.println(threadLocal1.get()+": "+threadLocal2.get());
        }
    }

![4b234b564aced10519a00ede03172d97.png][]

对ThreadLocal的正确理解：

*  ThreadLocal适用于线程需要有自己的实例变量，该实例变量可以在多个方法中被使用，但是不能被其他线程共享的场景。
 *  由于不存在数据共享，何谈同步？因此ThreadLocal 从理论上讲，不是用来解决多线程并发问题的。

**ThreadLocal的实现：**

最原始的想法：ThreadLocal维护线程与实例的映射。既然通过ThreadLocal对象为线程添加本地线程变量，那就将ThreadLocalMap放在ThreadLocal中。

![cfbc3e82fd753ce2db27787e587a4a28.png][]

原始想法存在的缺陷：多线程并发访问ThreadLocal中的Map，需要添加锁。这时， JDK 未采用该方案的一个原因。

优化后的方法：Thread维护ThreadLocal与实例的映射。Map是每个线程所私有，只能在当前线程通过ThreadLocal对象访问自身的Map。不存在多线程并发访问同一个Map的情况，也就不需要锁。

优化后存在内存泄露的情况：JDK1.8中，ThreadLocalMap每个Entry对ThreadLocal对象是弱引用，对每个实例是强引用。当ThreadLocal对象被回收后，该Entry的键变成null，但Entry无法被移除。使得实例被Entry引用无法回收，造成内存泄露。

![814b472b3d53468ba6796c5547b0103e.jpeg][]

[b6e75f9aa0e999d830ee187b018faa4b.png]: https://img-blog.csdnimg.cn/img_convert/b6e75f9aa0e999d830ee187b018faa4b.png
[d09a41239d6f41b2f0a4758603009c7c.png]: https://img-blog.csdnimg.cn/img_convert/d09a41239d6f41b2f0a4758603009c7c.png
[069df1c7e60dfc05dc3be5e6efddfa0c.png]: https://img-blog.csdnimg.cn/img_convert/069df1c7e60dfc05dc3be5e6efddfa0c.png
[4de9cb79537b9f219336af347c98c3b1.png]: https://img-blog.csdnimg.cn/img_convert/4de9cb79537b9f219336af347c98c3b1.png
[6a4af1a6588778908561ac40f1ffe653.png]: https://img-blog.csdnimg.cn/img_convert/6a4af1a6588778908561ac40f1ffe653.png
[4ee82cd17e181e9ada16fbde6ca38339.png]: https://img-blog.csdnimg.cn/img_convert/4ee82cd17e181e9ada16fbde6ca38339.png
[4b234b564aced10519a00ede03172d97.png]: https://img-blog.csdnimg.cn/img_convert/4b234b564aced10519a00ede03172d97.png
[cfbc3e82fd753ce2db27787e587a4a28.png]: https://img-blog.csdnimg.cn/img_convert/cfbc3e82fd753ce2db27787e587a4a28.png
[814b472b3d53468ba6796c5547b0103e.jpeg]: https://img-blog.csdnimg.cn/814b472b3d53468ba6796c5547b0103e.jpeg