本节内容：
并发模拟工具的使用、演示案例、线程安全性-原子性并演示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中的几种类进行讲解。）
可见性：概念就不说了，主要来精简一下导致共享变量在线程间不可见的原因
1、线程交叉执行
2、重排序结合线程交叉执行
3、共享变量更新后的值没有在工作内存与主内存间及时更新
那处理可见性我们也有几种方式：synchronized、lock、volatile
synchronized和lock能保证同一时刻只有一个线程获取锁然后执行同步代码。并在释放锁之前对变量的修改刷新到住内存中，以此来保证可见性。
在java内存模型中，关于synchronized有两条规定：
1、线程解锁前，必须把共享变量的最新值刷新到主内存。
2、线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。注意：加锁与解锁是同一把锁
当一个共享变量被volatile修饰时，它会保证修改的值立即被更新到主内存。其他线程读取时会从内存中读到新值。普通的共享变量不能保证可见性，其被写入内存的时机不确定。当其他线程去读，可能读到的是旧的值。
它的实现是通过内存屏障和禁止重排序优化来实现：
1、对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存。
2、对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。
有序性-先行发生原子（happens-before）
针对于内存模型中的有序来说，先行发生是java内存模型中定义的两项操作之间的偏序关系。
简单介绍一下java内存模型下一些天然的先行发生关系，这些关系无须任何同步器协助就已经存在，可在编码中直接使用。
程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作
锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作
volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于caozuoB
线程启动规则：Thread对象的start方法先行发生于此线程的每一个动作
线程中断规则：对线程interrupt方法的调用先行发生于被中断线程的代码检测到中断事件的发生
线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join方法结束Thread.isAlive的返回值手段检测到线程已经终止执行
对象终结规则：一个对象的初始化完成先行发生于他的finalize方法的开始