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

释放双眼,带上耳机,听听看~!

文章目录

  • 线程安全性

  • 基本概念

    • 三个基本原则
  • 原子性

  • Atomic
    * 锁

  • Lock (依赖特殊的cpu指令)
    * AQS 简介
    * Synchronized (依赖于JVM实现)

    
    
    1
    2
    3
    4
    1      * 原子性对比
    2
    3  * 可见性
    4
  • synchronized
    * volatile

    
    
    1
    2
    1  * 有序性
    2
  • happens-before原则

线程安全性

基本概念

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

三个基本原则

原子性

基本概念

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

线程不安全的类


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1@Slf4j
2@NotThreadSafe
3public class ConcurrencyTest {
4
5    // 请求总数
6    public static int clientTotal = 5000;
7
8    // 同时并发执行的线程数
9    public static int threadTotal = 200;
10
11    public static int count = 0;
12
13    public static void main(String[] args) throws Exception {
14        ExecutorService executorService = Executors.newCachedThreadPool();
15        final Semaphore semaphore = new Semaphore(threadTotal);
16        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
17        for (int i = 0; i < clientTotal ; i++) {
18            executorService.execute(() -> {
19                try {
20                    semaphore.acquire();
21                    add();
22                    semaphore.release();
23                } catch (Exception e) {
24                    log.error("exception", e);
25                }
26                countDownLatch.countDown();
27            });
28        }
29        countDownLatch.await();
30        executorService.shutdown();
31        log.info("count:{}", count);
32    }
33
34    private static void add() {
35        count++;
36    }
37}
38
39

当多个线程同时执行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 实现线程安全的自增


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
1@Slf4j
2@ThreadSafe
3public class AtomicExample1 {
4
5    // 请求总数
6    public static int clientTotal = 5000;
7
8    // 同时并发执行的线程数
9    public static int threadTotal = 200;
10
11    public static AtomicInteger count = new AtomicInteger(0);
12
13    public static void main(String[] args) throws Exception {
14        ExecutorService executorService = Executors.newCachedThreadPool();
15        final Semaphore semaphore = new Semaphore(threadTotal);
16        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
17        for (int i = 0; i < clientTotal ; i++) {
18            executorService.execute(() -> {
19                try {
20                    semaphore.acquire();
21                    add();
22                    semaphore.release();
23                } catch (Exception e) {
24                    log.error("exception", e);
25                }
26                countDownLatch.countDown();
27            });
28        }
29        countDownLatch.await();
30        executorService.shutdown();
31        log.info("count:{}", count.get());
32    }
33
34    private static void add() {
35        count.incrementAndGet();
36        // count.getAndIncrement();
37    }
38}
39
40

源码分析

静态代码块 通过 unsafe.objectFieldOffset 得到AtomicInger 对象中 value 字段的偏移量
JAVA并发编程(二)线程安全性

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

构造函数
JAVA并发编程(二)线程安全性
AtomicInteger 提供了两个构造方法,无参默认value 为0 ,如果传入值,则设置为 value 为传入的值, value 是通过 volatile 修饰,它的作用有两个

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

底层实现 Unsafe 实现
JAVA并发编程(二)线程安全性

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

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

CAS 缺点

  1. ABA问题

如果某个线程在CAS操作时发现,内存值和预期值都是A,就能确定期间没有线程对值进行修改吗?答案未必,如果期间发生了 A -> B -> A 的更新,仅仅判断数值是 A,可能导致不合理的修改操作。针对这种情况,Java 提供了 AtomicStampedReference 工具类,通过为引用建立类似版本号(stamp)的方式,来保证 CAS 的正确性。
循环时间长开销大

  1. CAS中使用的失败重试机制,隐藏着一个假设,即竞争情况是短暂的。大多数应用场景中,确实大部分重试只会发生一次就获得了成功。但是总有意外情况,所以在有需要的时候,还是要考虑限制自旋的次数,以免过度消耗 CPU。
  2. 只能保证一个共享变量的原子操作

Lock (依赖特殊的cpu指令)

代码实现


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
1@Slf4j
2@ThreadSafe
3public class LockExample2 {
4
5    // 请求总数
6    public static int clientTotal = 5000;
7
8    // 同时并发执行的线程数
9    public static int threadTotal = 200;
10
11    public static int count = 0;
12
13    private final static Lock lock = new ReentrantLock();
14
15    public static void main(String[] args) throws Exception {
16        ExecutorService executorService = Executors.newCachedThreadPool();
17        final Semaphore semaphore = new Semaphore(threadTotal);
18        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
19        for (int i = 0; i < clientTotal ; i++) {
20            executorService.execute(() -> {
21                try {
22                    semaphore.acquire();
23                    add();
24                    semaphore.release();
25                } catch (Exception e) {
26                    log.error("exception", e);
27                }
28                countDownLatch.countDown();
29            });
30        }
31        countDownLatch.await();
32        executorService.shutdown();
33        log.info("count:{}", count);
34    }
35
36    private static void add() {
37        lock.lock();
38        try {
39            count++;
40        } finally {
41            lock.unlock();
42        }
43    }
44}
45
46
47

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

AQS 简介

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

Synchronized (依赖于JVM实现)

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

代码实现


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1@Slf4j
2@ThreadSafe
3public class LockExample1 {
4
5    // 请求总数
6    public static int clientTotal = 5000;
7
8    // 同时并发执行的线程数
9    public static int threadTotal = 200;
10
11    public static int count = 0;
12
13    public static void main(String[] args) throws Exception {
14        ExecutorService executorService = Executors.newCachedThreadPool();
15        final Semaphore semaphore = new Semaphore(threadTotal);
16        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
17        for (int i = 0; i < clientTotal ; i++) {
18            executorService.execute(() -> {
19                try {
20                    semaphore.acquire();
21                    add();
22                    semaphore.release();
23                } catch (Exception e) {
24                    log.error("exception", e);
25                }
26                countDownLatch.countDown();
27            });
28        }
29        countDownLatch.await();
30        executorService.shutdown();
31        log.info("count:{}", count);
32    }
33
34    private synchronized static void add() {
35        count++;
36    }
37}
38
39

原子性对比

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

可见性

基本概念

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

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

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

synchronized

JMM关于synchronized的两条规定

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

volatile

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

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

使用volatile的时机

  • 对变量的写操作不依赖与当前值
  • 该变量没有包含具有其他变量不变的式子中

因此 使用valatile的变量一般作为标识符或者双重检测使用

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

有序性

基本概念

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

happens-before原则

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

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

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

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

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

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

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

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

给TA打赏
共{{data.count}}人
人已打赏
安全技术

Bootstrap 间隔 (Spacing)

2021-12-21 16:36:11

安全技术

从零搭建自己的SpringBoot后台框架(二十三)

2022-1-12 12:36:11

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索