并发编程2-线程安全性

Posted 2021-01-18 zhangblearn

本节内容：

　　并发模拟工具的使用、演示案例、线程安全性-原子性并演示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（内容有点多，明天更新）