线程安全

##线程安全

代码所在的进程有多个线程在同时运行，这些线程可能同时在运行同一段代码，如果每次运行结果和单线程运行一致，而且其他变量的值也和预期是一样的，则是线程安全的

线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据，造成所得到的数据是脏数据，也可能是计算时出现错误

## 并发模拟

- Postman : Http请求模拟工具
- Apache Bench(AB) : Apache附带的工具，测试网站性能
- JMeter : Apache组织开发的压力测试工具
- 代码 : Semaphore、CountDownLatch等

这些模拟工具中，JMeter是最方便实用的，推荐学习

下面写一下代码的并发模拟测试例子

```
package com.csyd.concurrency;

import com.csyd.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
//自定义的注解，代表线程不安全
@NotThreadSafe
public class ConcurrencyTest {

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

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

public static int count = 0;

public static void main(String[] args) throws Exception{
        //定义一个线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量，Semaphore是常用的并发测试类
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器递锁, CountDownLatch并发常用
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal; i++){
            //for循环请求放入线程池中
            executorService.execute(() -> {
                try {
                    // 线程池执行时引入信号量，acquire判断当前进程是否允许被执行
                    // 如果达到了一定并发数，可能会临时被阻塞掉，
                    // acquire返回值后，下面的add才会执行
                    semaphore.acquire();
                    add();
                    //释放
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
                // 每执行完一次后， 就会减一个
                countDownLatch.countDown();
            });
        }
        //当countDown减为0，就会执行，也就是所有的线程执行完
        countDownLatch.await();
        //关闭线程池
        executorService.shutdown();
        log.info("count:{}", count);
    }

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

```

执行后发现，每次的执行结果都不同，说明是线程不安全的

## 线程安全性

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

- 原子性：提供了互斥访问，同一时刻只能有一个线程来对它进行操作
- 可见性：一个线程对主内存的修改可以及时的被其他线程观察到
- 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序

### 原子性

**AtomicXXX:**
通过CAS（compareAndSwap）方法，在每次操作的时候，都从底层拿到该值，与传来的当前值做比较，如果是相同的，就继续操作，通过while循环不断重复，如果当前值与底层的值不同，则再去取值

**AtomicLong、LongAdder**
LongAdder和AtomicLong很像，但是不像Atomic一直while循环，效率更高，用什么byte，hash的，没听懂，低量的可以用简单的AtomicLong，多量的建议实用LongAdder

**AtomicReference、AtomicReferenceFieldUpdater**
AtomicReference使用compareAndSet(参数1,参数2)方法，判断当前值是否等于参数1，等于就把该值变成参数2
AtomicReferenceFieldUpdater是更新一个类的某个值，类中的这个值必须是volatile修饰的（不常用）

**AtomicStampReference:CAS的ABA问题
解决CAS操作时，其他线程把A改成B又改成A，使用当前线程A与主存变量比较时，发现A没有变，于是CAS就将A值交换操作，是不符合的，因此它将每CAS操作时，将变量版本号加1，这样判断版本号就能正确识别

**AtomicBoolean**
可以让代码只执行一次，即便是多个线程同时跑，也绝对不会重复，比较常用
```
private static void test(){
        if (isHappened.compareAndSet(false, true)){
            //可以让代码只执行一次，绝对不会重复
            log.info("execute");
        }
    }
```

**锁**

- synchronized：依赖JVM,不可中断的锁，适合竞争不激烈，可读性好
- Lock：依赖特殊的CPU指令，代码实现，ReentrantLock，可中断锁，多样化同步，竞争激烈时能维持常态

**synchronized**

1. 修饰代码块：大括号括起来的代码，作用于调用的对象
2. 修饰方法：整个方法，作用于调用的对象
3. 修饰静态方法：整个静态方法，作用于这个类的所有对象
4. 修饰类：括号括起来的部分，作用于这个类的所有对象

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

### 可见性

**不可见原因**

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

**解决方法**

**synchronized**
> **JMM关于synchronized的两条规定**
1. 线程解锁前，必须把共享变量的最新值刷新到主内存
2. 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值

**volatile**
> **通过加入内存屏障和禁止重排序优化来实现**
1. 对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的变量值刷新到主内存
2. 对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量

适合用于标识判断状态和double check（检查两次）

### 有序性
Java内存模型中，允许编译器和处理器对指令进行重排序，不会影响单线程执行，却会影响到多线程并发执行的正确性
可以通过volatile、synchronized、Lock保证有序性

**有序性 - happens-before原则**

- 程序次序规则：一个线程内，按照代码执行顺序，书写在前面的操作先行发生于书写在后面的操作
- 锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作
- volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
- 传递原则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C
- 线程启动原则：Thread对象的start()方法先行发生于此线程的每一个动作
- 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
- 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
- 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

耘朵

导航

最近发表

友情链接