【JAVA】：万字长篇带你了解JAVA并发编程-线程安全【四】-优快云博客

本文链接：https://blog.youkuaiyun.com/k316378085/article/details/134243812

个人主页: 【⭐️个人主页】
需要您的【💖 点赞+关注】支持 💯

JAVA并发系列文章

【JAVA】：万字长篇带你了解JAVA并发编程-线程安全【四】

🍀线程安全的基本概念

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

所以线程安全的定义如下：在多线程环境下，每次运行结果和单线程运行的结果是一样的，其他变量也和预期的是一样的

线程安全意义

线程安全，是指变量或方法( 这些变量或方法是多线程共享的) 可以在多线程的环境下被安全有效的访问。这说明了两方面的问题:
(1) 可以从多个线程中调用，无需调用方有任何操作;
(2) 可以同时被多个线程调用，无需线程之不必要的交互。

线程安全考虑的时机？

多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。

或者说：一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性，也就是说我们不用考虑同步的问题。

引起线程安全的情况

线程安全问题大多是由全局变量及静态变量引起的，局部变量逃逸也可能导致线程安全问题。

线程安全性的分类

根据共享数据的安全程度的强弱顺序线程安全性的分类方法包括：

不可变
线程安全
有条件线程安全
线程兼容
线程对立。

这种分类系统的核心是调用者是否可以或者必须用外部同步包围操作(或者一系列操作)。下面几节分别描述了线程安全性的这五种类别。

不可变

一个不可变的对象只要构建正确，其外部可见状态永远不会改变，永远也不会看到它处于不一致的状态。Java 类库中大多数基本数值类如Integer、String 和BigInteger 都是原子性的，是不可变的，但Long 和Double 就不能保证其操作的原子性，可在声明变量的时候用volatile 关键字。不可变对象上没有副作用，并且缓存不可变对象的引用总是安全的。一个不可变的对象的一个引用可以自由共享，而不用担心被引用的对象要被修改

线程安全

线程安全性类的对象操作序列( 读或写其公有字段以及调用其公有方法) 都不会使该对象处于无效状态，即任何操作都不会违反该类的任何不可变量、前置条件或者后置条件
不管运行时环境如何，调用者都不需要任何额外的同步措施

有条件的线程安全类

有条件的线程安全类对于单独的操作可以是线程安全的，但是某些操作序列可能需要外部同步。为了保证其它线程不会在遍历的时候改变集合，进行迭代的线程应该确保它是独占性地访问集合以实现遍历的完整性。通常，独占性的访问是由对锁的同步机制保证的
Java中的大部分线程安全类都是相对线程安全的

线程兼容

线程兼容类不是线程安全的，但可以通过正确使用同步从而在并发环境中安全地使用。或用一个synchronized 块包含每一个方法调用
Java API中的大部分都是，比如ArrayList和HashMap这些.

线程对立

线程对立类是那些不管是否调用了外部同步都不能在并发使用时保证其安全的类。线程对立类很少见，当类修改静态数据，而静态数据会影响在其它线程中执行的其它类的行为时，通常会出现线程对立

多线程编程中的三个核心概念

原子性

这一点，跟数据库事务的原子性概念差不多，即一个操作（有可能包含有多个子操作）要么全部执行（生效），要么全部都不执行（都不生效

可见性

可见性是指，当多个线程并发访问共享变量时，一个线程对共享变量的修改，其它线程能够立即看到。可见性问题是好多人忽略
或者理解错误的一点。

顺序性

顺序性指的是，程序执行的顺序按照代码的先后顺序执行。

🍀线程安全的实现方法

互斥同步

Java提供了两种锁机制来控制多个线程对共享资源的访问

JVM的synchronized
JDK实现的ReentrantLock
这两种锁机制可以保证操作中的原子性和可见性问题.

synchronized


public void func() {
    synchronized (this) {
        // ...
    }
}

public class SynchronizedExample {
    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}


public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}
public synchronized static void fun() {
    // ...
}

ReentrantLock

public class LockExe {

    private Lock lock = new ReentrantLock();

    public void func() {
        lock.lock();
        
        try {
             doSomeThing();
        } finally {
          // 确保释放锁，从而避免发生死锁。
            lock.unlock(); 
        }
    }
}

非阻塞同步

互斥同步的方法百分百的保证了线程安全问题，可是并不高效，因为它频繁的线程切换会导致大量的性能开销，所以被称为阻塞同步。这是一种悲观的并发策略，每次不管有没有线程与其竞争，都会上锁。

CAS

随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略: 先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施(不断地重试，直到成功为止)。
这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步
乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了只能靠硬件来完成。硬件支持的原子性操作最典型的是: 比较并交换(Compare-and-Swap，CAS)。
CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将V 的值更新为 B。

Atomiclnteger

J.U.C 包里面的整数原子类 Atomiclnteger，其中的 compareAndSet0 和 getAndIncrementl等方法都使用了 Unsafe 类的 CAS 操作。

CAS存在的ABA问题

如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。
J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效

无同步方案

要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。

栈封闭

多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。

线程本地存储(Thread Local Storage)

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

🍀线程安全的类与方法

通过synchronized 关键字给方法加上内置锁来实现线程安全

Timer，TimerTask，Vector，Stack，HashTable，StringBuffer

原子类Atomicxxx—包装类的线程安全类

如AtomicLong，AtomicInteger等等
Atomicxxx 是通过Unsafe 类的native方法实现线程安全的

BlockingQueue 和BlockingDeque

BlockingDeque接口继承了BlockingQueue接口，
BlockingQueue 接口的实现类有ArrayBlockingQueue ，LinkedBlockingQueue ，PriorityBlockingQueue 而BlockingDeque接口的实现类有LinkedBlockingDeque
BlockingQueue和BlockingDeque 都是通过使用定义为final的ReentrantLock作为类属性显式加锁实现同步的

CopyOnWriteArrayList和 CopyOnWriteArraySet

CopyOnWriteArraySet的内部实现是在其类内部声明一个final的CopyOnWriteArrayList属性，并在调用其构造函数时实例化该CopyOnWriteArrayList，CopyOnWriteArrayList采用的是显式地加上ReentrantLock实现同步，而CopyOnWriteArrayList容器的线程安全性在于在每次修改时都会创建并重新发布一个新的容器副本，从而实现可变性。

Concurrentxxx

最常用的就是ConcurrentHashMap，当然还有ConcurrentSkipListSet和ConcurrentSkipListMap等等。
ConcurrentHashMap使用了一种完全不同的加锁策略来提供更高的并发性和伸缩性。ConcurrentHashMap并不是将每个方法都在同一个锁上同步并使得每次只能有一个线程访问容器，而是使用一种粒度更细的加锁机制——segment分段锁来实现更大程度的共享