并发编程中的三大问题剖析与解决

---

首先让我们来了解一下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：当线程进入synchronized代码块时，会自动获取锁并执行代码，执行完毕后释放锁。在这个过程中，JVM会让所有其它线程停止工作并刷新所有线程的本地缓存，以确保它们看到的是最新的共享变量的值。
  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;
    }