JUC简介

最新推荐文章于 2023-03-27 21:55:39 发布

转载最新推荐文章于 2023-03-27 21:55:39 发布 · 101 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://juejin.im/post/5c0f5b74e51d4535112992bb

文章标签：

#java

本文深入解析Java并发编程，涵盖JUC包的高级特性，如线程池、异步IO及轻量级任务框架。探讨了内存可见性问题，volatile关键字与CAS算法的应用，以及CopyOnWriteArrayList和ConcurrentHashMap等集合类的使用场景。同时，详细介绍了Java创建线程的四种方式及其优缺点，线程安全解决方案，以及生产者与消费者模式中的线程同步技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JUC简介

在Java 5.0 提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等。

内存可见性问题：当多个线程操作共享数据时，彼此不可见
volatile 关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。相较于 synchronized 是一种较为轻量级的同步策略。

注意： 1. volatile 不具备“互斥性” 2. volatile 不能保证变量的“原子性”

i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”

	      int i = 10;
	      i = i++; //10
	      int temp = i;
	      i = i + 1;
	      i = temp;
复制代码

原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
1. volatile 保证内存可见性
2. CAS（Compare-And-Swap）算法保证数据变量的原子性 CAS 算法是硬件对于并发操作的支持 CAS 包含了三个操作数： ①内存值 V ②预估值 A ③更新值 B 当且仅当 V == A 时， V = B; 否则，不会执行任何操作。
3. CAS算法要比同步锁的效率高很多，因为线程不会阻塞，它可以马上去读，然后更新值。
4. CAS也是硬件对于并发操作的支持
CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制” 注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。
CurrentHashMap: - 参考1 - 参考2
java创建线程的4中方式
1. 继承Thread类（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。（2）创建Thread子类的实例，即创建了线程对象。（3）调用线程对象的start()方法来启动该线程。
2. 通过Runnable接口创建线程类（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。（3）调用线程对象的start()方法来启动该线程。
3. 通过Callable和Future创建线程（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值（5）FutureTask也可以用于闭锁的操作。
线程池方式
- 对比：
  - 采用实现Runnable、Callable接口的方式创见多线程时。
    - 优势是：
      - 线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
      - 在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
    - 劣势是：编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
  - 使用继承Thread类的方式创建多线程时。
    - 优势：编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
    - 劣势：线程类已经继承了Thread类，所以不能再继承其他父类。
用于解决多线程线程安全的方式：
- jdk1.5以前：
  - Synchronize:隐式锁
    - 同步代码块
    - 同步方法
- jdk1.5以后：
  - 同步锁lock：
    - 显示锁，必须通过lock()方法进行上锁，同时也必须通过unLock()方法释放锁
    - 问题：需要保证锁会释放，所以一般unLock()要放在finally下面
生产者与消费者
- 不用等待唤醒机制，会产生的问题：
  - 重复调用占用资源问题
    - 原因分析：上述的情况是当没货的时候还会继续调用该方法，从而占用资源，二货满的情况下也会重复调用进货方法，占用资源，这样是不合理的。
    - 解决方式：当货满了，应该停止进货，释放锁让消费者消费，当没货了应该停止消费释放锁，让进货，这是我们想要的逻辑。使用wait()和notifyAll()这两个方法来实现。
  - 线程阻塞无法唤醒
    - 原因分析当product比较小假如是1的时候，有可能生产者先循环结束，消费者还没结束，一直在waite无法得到唤醒就一直等待程序就会停在那里
    - 解决方式去掉else，保证每次都会唤醒另外一个线程
  - 虚假唤醒问题当只有一个Factory有两个Consumer的时候就会出现虚假唤醒问题。导致商品都成了负数了。
    - 原因分析：当创建对个生产消费者线程的时候，会产生虚假唤醒，导致product 为负数，是因为当消费者线程A发现没货的时候，wait之后释放锁，另外一个消费者线程B获得锁开始执行，结果也没货，开始wait，当生产者生产之后notifyAll，A，B线程开始继续向下执行，结果进行了两次–操作，导致product成为了负数
    - 解决方式： JDK文档object的wait方法已经考虑到这种情况，防止虚假唤醒，应该放在循环中，多次进行检查，直到满足条件才进行下一步。即不要使用if来进行判断而用while循环来进行判断
  - 守护线程解决线程阻塞上面解决了虚假唤醒问题，但是当多个消费者和一个生产者的时候，生产者有可能先结束循环，但是消费者还没结束，结果到了其他消费者的时候发现product是小于0的于是就wait，程序一直等待得不到结束，就会一直在wait()
    - 解决方式：在共享资源clerk类中定义生产者线程标志位，在main线程中创建一个线程设置为守护线程并启动，在该守护线程中创建匿名内部类Runnable并在run方法中判断生产者线程isAlive()如果生产者线程结束，就把标志位置为false，该标识位和消费者线程的while判断条件中串联。当生产者线程为false的之后短路，使得消费和线程啥都不做，直到线程结束。
      - Clerk中设置Factory线程的标志位
```
    private boolean facctoryFlg = true;//工厂线程结束的标志位，为false表示线程执行完毕
        public boolean isFacctoryFlg() {
            return facctoryFlg;
        }
        public void setFacctoryFlg(boolean facctoryFlg) {
            this.facctoryFlg = facctoryFlg;
        }     
复制代码
```
      - 主方法中创建守护线程
```
 //创建守护线程
          Thread daemon = new Thread(new Runnable() {
              @Override
              public void run() {
                 while(true){
                    if(!tf.isAlive()){
                        clerk.setFacctoryFlg(false);
                        System.out.println("factory--------------"+tf.isAlive());
                        break;
                    }
                 }
              }
          });
          daemon.setDaemon(true);//设置为守护线程(后台线程)
          daemon.start();
复制代码
```
      - 修改Clerk的sale方法：
```
//售货
    public synchronized void sale(){

        while(product<=0){
            //当Factory线程结束的时候，直接结束sale方法
            if(!isFacctoryFlg()){
                return;
            }
            System.out.println("没货了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println(Thread.currentThread().getName()+"卖货"+product);
            --product;
            notifyAll();
        }
  	  ```
      复制代码
```
通过守护线程daemon的监视，可以避免线程阻塞的情况，就算有多个消费者或者Factory只要在守护线程中添加判断逻辑，就可以避免阻塞的出现。