JAVA并发编程(二)线程安全性

线程安全性

基本概念

当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的

三个基本原则

原子性

基本概念

提供了互斥访问，同一时刻，只能有一个线程来对它进行操作

线程不安全的类

@Slf4j
@NotThreadSafe
public class ConcurrencyTest {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    private static void add() {
        count++;
    }
}

当多个线程同时执行add方法时，由于cpu缓存及线程的切换，导致了数据的不一致。这就引起了所谓的线程安全问题

Atomic

Atomic 包 是 JDK 提供的一个 原子操作包，位于 J.U.C 下，它提供了一系列的操作简单，性能高效，并能保证线程安全的类去更新基本类型变量，数组元素，引用类型以及更新对象中的字段类型。atomic包下的这些类都是采用的是乐观锁策略去原子更新数据，在java中则是使用CAS操作具体实现。

CAS

CAS(compare-and-swap)直译即比较并交换，提供原子化的读改写能力，是Java 并发中所谓 lock-free 机制的基础。
CAS的思想很简单：三个参数，一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。
在JAVA中,CAS通过调用C++库实现，由C++库再去调用CPU指令集。不同体系结构中，cpu指令还存在着明显不同。比如，x86 CPU 提供 cmpxchg 指令；而在精简指令集的体系架构中，（如“load and reserve”和“store conditional”）实现的，在大多数处理器上 CAS 都是个非常轻量级的操作，这也是其优势所在。

AtomicInteger 实现线程安全的自增

@Slf4j
@ThreadSafe
public class AtomicExample1 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count.get());
    }

    private static void add() {
        count.incrementAndGet();
        // count.getAndIncrement();
    }
}

源码分析

静态代码块 通过 unsafe.objectFieldOffset 得到AtomicInger 对象中 value 字段的偏移量

Unsafe 是基于操作系统级别的原子操作类，是java中对大多数锁机制实现的最基础类

构造函数

AtomicInteger 提供了两个构造方法，无参默认value 为0 ，如果传入值，则设置为 value 为传入的值， value 是通过 volatile 修饰,它的作用有两个

1. 禁止指令重排序
2. .保证此变量对所有的线程的可见性，也就是当一个线程修改了该变量时，其他线程是可见的。（所有线程读取该数据都通过主存读取 当对该变量进行写入时，马上同步到主内存。不需要经过高速缓存）

底层实现 Unsafe 实现

var1 为 当前对象，var2 为 value 值 在内存中的偏移量，var 4 是需要增加的值 var5是当前内存中此字段的值，通过预期值 var5 与 内存中的实际值 var1,var2 来判断是否相同，相同则更新，不相同则不更新，返回的结果为是否更新。使用了一个自旋操作(自旋锁)来循环判断

当预期值和内存值是一样的时候，更新操作此时为原子操作。一方面通过 valatile 来通过直接访问内存得到数据，避免了高速缓存所导致的数据不一致，第二方面，在更新数据时，是原子操作。保证数据更新之前其他线程在等待。保证了更新数据时的正确性。

CAS 缺点

1. ABA问题
   如果某个线程在CAS操作时发现，内存值和预期值都是A，就能确定期间没有线程对值进行修改吗？答案未必，如果期间发生了 A -> B -> A 的更新，仅仅判断数值是 A，可能导致不合理的修改操作。针对这种情况，Java 提供了 AtomicStampedReference 工具类，通过为引用建立类似版本号（stamp）的方式，来保证 CAS 的正确性。
   循环时间长开销大
2. CAS中使用的失败重试机制，隐藏着一个假设，即竞争情况是短暂的。大多数应用场景中，确实大部分重试只会发生一次就获得了成功。但是总有意外情况，所以在有需要的时候，还是要考虑限制自旋的次数，以免过度消耗 CPU。
3. 只能保证一个共享变量的原子操作

锁

Lock （依赖特殊的cpu指令）

代码实现

@Slf4j
@ThreadSafe
public class LockExample2 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    private final static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    private static void add() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

底层实现依赖于AQS 及CAS实现

AQS 简介

AQS是AbustactQueuedSynchronizer的简称，它是一个Java提供的底层同步工具类，用一个int类型的变量表示同步状态，并提供了一系列的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，例如ReentrantLock，CountdowLatch就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同步组件的内部类。

Synchronized (依赖于JVM实现)

• 修饰代码块:大括号括起来的代码，作用于调用的对象
• 修饰方法:整个方法,作用于掉用的对象
• 修饰静态方法 : 整个静态方法，作用于所有对象
• 修饰类 ： 括号括起来的部分，作用于所有对象

代码实现

@Slf4j
@ThreadSafe
public class LockExample1 {

    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}", count);
    }

    private synchronized static void add() {
        count++;
    }
}

原子性对比

synchronized:不可中断锁，适合竞争不激烈，可读性好
Lock：可中断锁，多样化同步，竞争激烈时能维持常态
Auomic:竞争激烈时能维持常态，比Lock性能好；只能同步一个值

可见性

基本概念

一个线程对主内存中数据的修改可以及时的被其他线程所观察到

导致共享变量在线程间不可见的原因

• 线程交叉执行
• 重排序结合线程交叉执行
• 共享变量更新后的值没有在工作内存与主内存间及时更新

synchronized

JMM关于synchronized的两条规定

• 线程解锁前，必须把共享变量的最新值刷新到主内存
• 线程加锁前，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值(加锁与解锁是同一把锁)

volatile

通过加入内存屏障和禁止重排序优化来实现

• 对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存
• 对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量

使用volatile的时机

• 对变量的写操作不依赖与当前值
• 该变量没有包含具有其他变量不变的式子中
  因此 使用valatile的变量一般作为标识符或者双重检测使用

有序性

基本概念

一个线程能够观察到其他线程指令执行的顺序，由于指令重排序，该结果一般杂乱无序。Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性

happens-before原则

程序次序规则 : 一个线程内、按照代码顺序、书写在前面的操作先行发生于书写在后面的操作

锁定规则: 一个unLock操作先行发生于后面对同一个锁的Lock操作

volatile变量规则 ：对一个变量的写操作先行发生于后面对这个变量的读操作

传递规则: 如果操作A先行发生于操作B，而操作B又先行发生于操作C、则可以得出操作A先行发生于操作C

线程启动原则: Thread对象的start()方法先行发生于此线程的每一个动作

线程中断规则:对线程interrupt（）方法的调用先行发生于被中断线程的代码检测到中断时间的发生

线程终结规则；线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行

对象终结规则: 一个对象的初始化完成先行发生于他的finalize()方法的开始