并发编程-线程安全性

本节内容：

　　并发模拟工具的使用、演示案例、线程安全性-原子性并演示JUC之Atomic包、回顾synchronized、lock、volatile关键字

---

并发模拟工具：JMeter。我用的是windows下的，关于中文只需修改JMeter的bin目录下的jmeter.properties。修改language=zh_CN 再次运行jmeter.bat打开就是中文版。

主界面打开，建立一个线程组。先了解一下线程属性。线程数：指虚拟用户数。Ramp-up：虚拟用户增加时长，用户作某一个操做的高峰期时长 分钟*秒。循环次数：虚拟用户作操做几回后中止。接下里开始一个简单的操做。在线程组上建立Http请求-建立图形结果-建立察看结果树-选项中设置日志查看。一些对应的参数这里就不作讲解了。经过图形结果和结果树咱们能够清楚的看到并发时的接口状况，和每次请求详细的状况。

---

 并发模拟代码：咱们利用一些辅助类来构建并发代码。CountDownLatch和Semaphore

CountDownLatch：位于java.util.concurrent包下，利用它能够实现相似计数器的功能。好比有一个任务A，它要等待其余4个任务执行完毕以后才能执行，此时就能够利用CountDownLatch来实现这种功能了。

该类只提供了一个构造器

public CountDownLatch(int count) {  };  //参数count为计数值

还有三个重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()相似，只不过等待必定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

　　

如图示：计数器初始值为3，线程A调用await方法后，进程进入等待状态。其余进程代码里执行countDown时，计数器减1.当计数器为0时，线程A才继续执行。该类能够阻塞线程并保证线程知足某种特定状况下继续执行。

---

 Semaphore：字面量就是信号量。能够控制同时访问的线程个数，经过 acquire() 获取一个许可，若是没有就等待，而 release() 释放一个许可。

Semaphore类位于java.util.concurrent包下，它提供了2个构造器：

public Semaphore(int permits) {          //参数permits表示许可数目，即同时能够容许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是不是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

 其中有几个重要的方法：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

acquire()用来获取一个许可，若无许可可以得到，则会一直等待，直到得到许可。

release()用来释放许可。注意，在释放许可以前，必须先获得到许可。

这4个方法都会被阻塞，若是想当即获得执行结果，可使用下面几个方法：

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则当即返回true，若获取失败，则当即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则当即返回true，不然则当即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则当即返回true，若获取失败，则当即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则当即返回true，不然则当即返回false

---

 咱们如今利用这两个辅助类，来完成一段并发演示代码。首先介绍一下，我本身定义了几个注释来区别不一样的类：

@NoRecommend：标记不推荐的类或写法
@Recommend：标记推荐的类或写法
@NotThreadSafe：线程不安全的类或写法
@ThreadSafe：线程安全的类或写法

 首先咱们建立一个线程不安全的类：

@NotThreadSafe
public class ConcurrencyExample1 {
    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;
    //共享资源
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        //建立线程池
        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) {
                    System.out.println("exception:"+e.getMessage());
                }
　　　　　　　　　　　//将计数值减1
                countDownLatch.countDown();
            });
        }
　　　　　　//保证全部进程执行完
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count:{}"+count);
    }
    private static void add(){
        count++;
    }
}

 屡次执行会发现count的最终结果并非5000，缘由我就不在讲述了，在以前的相关博文中这一线程安全问题已经讲了好几遍了。

既然出现了线程不安全咱们就来复习一下何为线程安全性：

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

 那么关于线程安全性又有很重要的：原子性、可见性、有序性了。此处将以前的概念进行了小小的精简。

原子性：提供了互斥访问，同一时刻只能有一个线程来怼它进行操做。
可见性：一个线程对主内存的修改能够及时的被其余线程观察到。
有序性：一个线程观察其余线程中的指令执行顺序，因为指令重排序的存在，该观察结果通常杂乱无序。

---

 在以前的多线程模块中。咱们已经了解了可见性及有序性的处理。如今咱们学一下如何在并发编程时保证原子性。

原子性：并发包JUC--Atomic（此节单独对Atomic中的几种类进行讲解。）

---

 可见性：概念就不说了，主要来精简一下致使共享变量在线程间不可见的缘由

　　一、线程交叉执行

　　二、重排序结合线程交叉执行

　　三、共享变量更新后的值没有在工做内存与主内存间及时更新

那处理可见性咱们也有几种方式：synchronized、lock、volatile

　　synchronized和lock能保证同一时刻只有一个线程获取锁而后执行同步代码。并在释放锁以前对变量的修改刷新到住内存中，以此来保证可见性。

　　在java内存模型中，关于synchronized有两条规定：

　　一、线程解锁前，必须把共享变量的最新值刷新到主内存。

　　二、线程加锁时，将清空工做内存中共享变量的值，从而使用共享变量时须要从主内存中从新读取最新的值。注意：加锁与解锁是同一把锁

　　当一个共享变量被volatile修饰时，它会保证修改的值当即被更新到主内存。其余线程读取时会从内存中读到新值。普通的共享变量不能保证可见性，其被写入内存的时机不肯定。当其余线程去读，可能读到的是旧的值。

　　它的实现是经过内存屏障和禁止重排序优化来实现：

　　一、对volatile变量写操做时，会在写操做后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存。

　　二、对volatile变量读操做时，会在读操做前加入一条load屏障指令，从主内存中读取共享变量。

---

 有序性-先行发生原子（happens-before）

　　针对于内存模型中的有序来讲，先行发生是java内存模型中定义的两项操做之间的偏序关系。

　　简单介绍一下java内存模型下一些自然的先行发生关系，这些关系无须任何同步器协助就已经存在，可在编码中直接使用。

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

　　锁定规则：一个unLock操做先行发生于后面对同一个锁的lock操做

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

　　传递规则：若是操做A先行发生于操做B，而操做B又先行发生于操做C，则能够得出操做A先行发生于caozuoB

　　线程启动规则：Thread对象的start方法先行发生于此线程的每个动做

　　线程中断规则：对线程interrupt方法的调用先行发生于被中断线程的代码检测到中断事件的发生

　　线程终结规则：线程中全部的操做都先行发生于线程的终止检测，咱们能够经过Thread.join方法结束Thread.isAlive的返回值手段检测到线程已经终止执行

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