文章目录
-
线程安全性
-
基本概念
- 三个基本原则
-
原子性
-
Atomic
* 锁 -
Lock （依赖特殊的cpu指令）
* AQS 简介
* Synchronized (依赖于JVM实现)1
2
3
41 * 原子性对比
2
3 * 可见性
4 -
synchronized
* volatile1
21 * 有序性
2 -
happens-before原则
线程安全性
基本概念
当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的
三个基本原则
原子性
基本概念
提供了互斥访问，同一时刻，只能有一个线程来对它进行操作
线程不安全的类
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
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 实现线程安全的自增
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
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 字段的偏移量
Unsafe 是基于操作系统级别的原子操作类，是java中对大多数锁机制实现的最基础类
构造函数
AtomicInteger 提供了两个构造方法，无参默认value 为0 ，如果传入值，则设置为 value 为传入的值， value 是通过 volatile 修饰,它的作用有两个
- 禁止指令重排序
- .保证此变量对所有的线程的可见性，也就是当一个线程修改了该变量时，其他线程是可见的。（所有线程读取该数据都通过主存读取 当对该变量进行写入时，马上同步到主内存。不需要经过高速缓存）
底层实现 Unsafe 实现
var1 为 当前对象，var2 为 value 值 在内存中的偏移量，var 4 是需要增加的值 var5是当前内存中此字段的值，通过预期值 var5 与 内存中的实际值 var1,var2 来判断是否相同，相同则更新，不相同则不更新，返回的结果为是否更新。使用了一个自旋操作(自旋锁)来循环判断
当预期值和内存值是一样的时候，更新操作此时为原子操作。一方面通过 valatile 来通过直接访问内存得到数据，避免了高速缓存所导致的数据不一致，第二方面，在更新数据时，是原子操作。保证数据更新之前其他线程在等待。保证了更新数据时的正确性。
CAS 缺点
- ABA问题
如果某个线程在CAS操作时发现，内存值和预期值都是A，就能确定期间没有线程对值进行修改吗？答案未必，如果期间发生了 A -> B -> A 的更新，仅仅判断数值是 A，可能导致不合理的修改操作。针对这种情况，Java 提供了 AtomicStampedReference 工具类，通过为引用建立类似版本号（stamp）的方式，来保证 CAS 的正确性。
循环时间长开销大
- CAS中使用的失败重试机制，隐藏着一个假设，即竞争情况是短暂的。大多数应用场景中，确实大部分重试只会发生一次就获得了成功。但是总有意外情况，所以在有需要的时候，还是要考虑限制自旋的次数，以免过度消耗 CPU。
- 只能保证一个共享变量的原子操作
锁
Lock （依赖特殊的cpu指令）
代码实现
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
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实现)
- 修饰代码块:大括号括起来的代码，作用于调用的对象
- 修饰方法:整个方法,作用于掉用的对象
- 修饰静态方法 : 整个静态方法，作用于所有对象
- 修饰类 ： 括号括起来的部分，作用于所有对象
代码实现
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
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内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性
happens-before原则
程序次序规则 : 一个线程内、按照代码顺序、书写在前面的操作先行发生于书写在后面的操作
锁定规则: 一个unLock操作先行发生于后面对同一个锁的Lock操作
volatile变量规则 ：对一个变量的写操作先行发生于后面对这个变量的读操作
传递规则: 如果操作A先行发生于操作B，而操作B又先行发生于操作C、则可以得出操作A先行发生于操作C
线程启动原则: Thread对象的start()方法先行发生于此线程的每一个动作
线程中断规则:对线程interrupt（）方法的调用先行发生于被中断线程的代码检测到中断时间的发生
线程终结规则；线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
对象终结规则: 一个对象的初始化完成先行发生于他的finalize()方法的开始
