---

首先让我们来了解一下JUC

JUC（Java Util Concurrent）是Java提供的一个并发编程工具包，它解决了在多线程程序中可能遇到的各种并发问题，例如线程安全、死锁、竞态条件等。JUC提供了许多用于控制并发访问的类和接口，如ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等，这些工具可以帮助开发人员更加方便、高效地编写多线程程序，并减少由于并发问题而导致的程序错误和性能下降。

可见性

线程修改之后，其他线程也能立刻看到。
一个线程对共享变量进行修改，另一个先立即得到修改后的最新值，代码如下

 public static Boolean run = true;
    public static void main(String[] args) throws InterruptedException {
//        创建一个线程让他一直执行
        Thread t1 = new Thread(() -> {

            while (run) {
//                System.out.println("一直执行...");
            }
        });
        t1.start();

        Thread.sleep(200);

//        修改这个run的值，然后让方法一停止运行
        Thread t2 = new Thread(() -> {
            run = false;
            System.out.println("修改值完成");
        });
        t2.start();
    }

结果就是一直执行，无法停止，这是因为在这个线程中修改之后，变化的只有这个线程

原因分析：

如下就是这流程图，线程中执行完毕之后，线程保存了共享变量却无法保存在内存中。

解决：

这里我们就可以使用java中的关键字

• voliate：每次变量修改之后，就会去将主内存中的变量去情况，还有各个线程中的变量也去清空
  这样如果这个线程再次使用的时候，就会再次去主内存中去读取这个变量的数据。
• synchronized：这里就去定义一个对象，去设置一个相当于是锁的对象，原理与voliate相同
  public static voliate Boolean run = true;

需要注意的是：在写System.out.println(“一直执行…”);因为它的底层是有加synchronized，所以就不会存在可见性问题

原子性

原子型就是因为有一个任务必须一次性完成，中间不会被其他线程去干扰。
模拟原子操作

1. 创建五个线程
2. 对同一个变量进行++操作
3. 最后查看结果，就可以确定是否是原子操作

    //        定义添加的变量
    static int num = 0;

    public static void main(String[] args) throws InterruptedException {
//        定义线程操作
        Runnable runnable = () -> {
//            自增操作
            for (int i = 0; i < 1000; i++) {
                num++;
            }
        };

//        定义一个集合去存放着五个线程，为了防止一次执行完毕
        ArrayList<Thread> runnableList = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(runnable);
            t.start();
            runnableList.add(t);
        }

        for (Thread run : runnableList) {
            run.join();
        }

        System.out.println(num);
    }

运行结果如下

即使我们即使去释放了这个代码中的每个线程的执行，还是可能发生没有加到5000的情况

原因分析：

这个是反编译之后的结果，在图中我们可以看到画红框的四个量中，就是对这个数进行读取与写入的操作，很明显的可以看到，下面的操作并不是原子操作的，所以就有可能发生并发问题。

解决：

这里也使用synchronized来解决，只需要对num++这一步加锁即可

public static Object obj = new Object();
public static void main(String[] args) throws InterruptedException {
    ……
    synchronized (obj) {
        num++;
    }
    ……
}

有序性

一个线程不会因为计算机的优化，而将代码执行顺序进行调整。

这里补充一下，计算机的重排序不会是任意排序的，而是有规则的，列举几种不会重排序的情况
列如：写后读
Int a = 1;
Int b = a;
写后写
Int a = 1;
Int a = 2;
读后写
int a = 1;
Int b = 2;
Int a = 2;

总之就是对不会产生依赖的操作进行重排序，这些操作就可能被编译器和处理器重排序

下面举一个栗子

   /**
    * 开启两个压测的线程，让他们去执行
    *   第一个方法去输出值，第二个方法去赋值
    *   那么我们只需要去判断可能出现的一个情况，就能知道，是否重排
    *  情况列举：
    *       线程执行到num=2,ready是false输出：r1 = 1
    *       线程执行到rc2,方法执行完毕之后，在执行ac1输出r1 = 4
    *
    *      最后一种情况是因为指令重排才可能出现：
    *       就有可能出现ac2重排，那么就会出现下面这种情况
    *           ready = true
    *           num = 2
    *          最后因为ready = true，然后切换到ac1这个方法r1 = 0
    */
代码实现
int num = 0;
 boolean ready = false;

 @Actor
 public void actor1(I_Result r) {
     if (ready) {
         r.r1 = num + num;
     } else {
         r.r1 = 1;
     }
 }

 @Actor
 public void actor2(I_Result r) {
     num = 2;
     ready = true;
 }

最后结果分析r1 = 0也是有的

解决：

    synchronized (obj) {
        if (ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    synchronized (obj) {
        num = 2;
        ready = true;
    }