JUC与多线程基础详解

最新推荐文章于 2025-03-27 16:30:45 发布

码上言

最新推荐文章于 2025-03-27 16:30:45 发布

阅读量860

点赞数 23

分类专栏：多线程 Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/m0_37779600/article/details/136357736

版权

Java 同时被 2 个专栏收录

22 篇文章

订阅专栏

多线程

2 篇文章

订阅专栏

⭐ 作者简介：码上言

⭐ 代表教程：Spring Boot + vue-element 开发个人博客项目实战教程

⭐专栏内容：个人博客系统

⭐我的文档网站：http://xyhwh-nav.cn/

文章目录

- JUC与多线程基础详解

JUC与多线程基础详解

什么是JUC？

JUC（Java Util Concurrent）是 Java 5 以后新增的一组并发编程工具包，提供了一系列高效、线程安全的并发集合，方便在多线程环境下处理共享数据。

JUC其实就是JDK中的三个包:

java.util.concurrent 并发相关的
java.util.concurrent.atomic 原子性
java.util.concurrent.locks lock锁

为什么要使用并发编程

1. 充分利用多核CPU的计算能力：通过并发编程的形式可以将多核CPU的计算能力发挥到极致，性能得到提升。
1. 方便进行业务拆分，提升系统并发能力和性能。

并发编程有什么缺点

内存泄露，上下文切换，线程安全，死锁等等

内存泄漏：指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

上下文切换：多线程编程中一般线程的个数都大于CPU核心的个数，而一个CPU核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU采取的策略是为了每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。

线程安全：当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为。

死锁：死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

并发编程三要素是什么？在java程序中怎么保证多线程的运行安全

三要素：

原子性：一个或多个操作要么全部执行成功要么全部执行失败
可见性：一个线程对共享变量的修改，另一个线程能看见
有序性：程序执行的顺序按照代码的先后顺序执行

出现线程安全问题的原因：

线程切换带来的原子性问题
缓存导致的可见性问题
编译优化带来的有序性问题

解决

JDK中 Atomic开头的原子类，synchronized，Lock，可以解决原子性问题
synchronized，volatile，Lock，可以解决可见性问题
Happens-Bofore规则可以解决有序性问题

什么是上下文切换？什么原因会造成上下文切换？

线程在执行过程中会有自己的运行条件和状态(也称上下文)，当出现如下情况的时候，线程会从占用 CPU 状态中退出。

主动让出 CPU，比如调用了 sleep(), wait() 等。
时间片用完，因为操作系统要防止一个线程或者进程长时间占用CPU导致其他线程或者进程饿死。
调用了阻塞类型的系统中断，比如请求 IO，线程被阻塞。
被终止或结束运行

这其中前三种都会发生线程切换，线程切换意味着需要保存当前线程的上下文，留待线程下次占用 CPU 的时候恢复现场。并加载下一个将要占用 CPU 的线程上下文。这就是所谓的 上下文切换。

上下文切换是现代操作系统的基本功能，因其每次需要保存信息恢复信息，这将会占用 CPU，内存等系统资源进行处理，也就意味着效率会有一定损耗，如果频繁切换就会造成整体效率低下。

synchronized

synchronized是Java的一个关键字，是一个内部锁。它可以使用在方法和方法块上，表示同步方法和同步代码块。在多线程环境下，同步方法和同步代码块在同一时刻只允许有一个线程执行，其他线程都在等待获取锁。

synchronized是如何保证三要素的：

原子性：锁通过互斥来保障原子性，临界区代码只能被一个线程执行
可见性：synchronized内部锁通过写线程冲刷处理器缓存和读线程刷新处理器缓存保证可见性
有序性：保障了原子性和可见性，即可保障有序性

synchronized底层实现原理

**同步代码块：**通过monitorenter和monitorexit指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令指向同步代码块的结束位置，当执行monitorenter指令时，线程试图获取锁也就是获取monitor（monitor对象存在于每个Java对象的对象头中，synchronized锁便是通过这种方式获取锁的，也是为什么java中任意对象可以作为锁的原因）的持有权。

其内部包含一个计数器，当计数器为0则可以成功获取，获取后将锁计数器设为1。相应的执行了monitorexit指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

**同步方法：**ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

synchronized锁升级的过程

在jdk1.6后java对synchronized锁进行了升级过程，主要包含了偏向锁，轻量级锁和重量级锁，主要是针对对象头MarkWord的变化

（1）偏向锁

经过大量的研究发现，大多数时候是不存在锁竞争的，常常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。偏向锁是指一段同步代码一直被一个线程所访问，那么该线程就会自动获取锁。降低获取锁的代价。

（2）轻量级锁

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

（3）重量级锁

重量级锁是指当锁是轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低

（4）自旋锁

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少了线程上下文切换的消耗，缺点是循环会消耗CPU

请你谈谈对于volatile的理解

volatile关键字是一种轻量级的锁，可以保证可见性和有序性，但是不能保证原子性。

volatile如何保证了可见性和有序性？

变量可见性：当一个线程改编了线程共享变量的值，其他线程能够立即得知这个修改的新值。
禁止重排序：重排序是JVM为了优化指令，提高程序运行效率，在不影响单线程程序执行结果的前提下，尽可能的提高并发度。Java编译器会在生成指令系列时在适当的位置插入内存屏障来禁止重排序。对一个volatile字段进行写操作，Java内存模型将在写操作后插入一个写屏障指令，这个指令会把之前的写入值都刷新到内存。

public class demo1 {
    //这种情况下就是无法可见的，对于主内存中的变量来说。
    //private static int num = 0;
    //这种情况下就是可以被看见的，加了volatile关键字之后。
    private volatile static int num = 0;
    public static void main(String[] args) {

        new Thread(()->{
            while(num==0){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }
}

volatile是不保证原子性的，这里如果想保证原子性的话，那就需要使用synchronized关键字或者lock锁的方法，但是也可以使用AtomicInteger的方法，底层是CAS原理，效率更高。

public class demo2 {
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        //AtomicInteger + 1方法，CAS效率超级高，并且可以保证原子性。
        num.getAndIncrement();
    }
    public static void main(String[] args) {
        for(int i=0;i<20;i++){
            new Thread(()->{
                for(int j=0;j<1000;j++){
                    add();
                }
            }).start();
        }
        while(Thread.activeCount()>2){
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

Lock

Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。

Lock优点如下：

可以使锁更公平
使线程在等待锁的时候响应中断
让线程尝试获取锁，并且在无法获取锁的时候立即返回或者等待一段时间
在不同的范围，以不同的顺序获取和释放锁

整体来说Lock是synchronized的扩展版，Lock提供了无条件，可轮询的（tryLock方法），定时的（tryLock带参方法），可中断的（lockInterruptibly），可多条件队列的（new Condition方法）锁操作。另外Lock的实现类基本都支持非公平锁和公平锁。synchronized只支持非公平锁。

Lock是一个接口，具有三个实现类：

ReentrantLock可重入锁
ReentrantReadWriteLock.ReadLock读锁
ReentrantReadWriteLock.WriteLock写锁

Synchronized 和 Lock的区别是什么？

Synchronized 内置的Java关键字， Lock是一个Java类，一个接口。
Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁，isHeldByCurrentThread()，检查当前线程是否持有此锁，isLocked()，是否有任何线程持有此锁，如果有返回true。查询等待队列中的线程数量：getQueueLength()。
Synchronized 会自动释放锁， Lock需要手动释放锁。如果不释放锁，就会产生死锁。
Synchronized 当线程想要获取锁的时候，发现锁被占用了，那么线程就会被挂起，进入阻塞状态直到这个锁可以用了，也就是说没有超时机制（tryLock）或者中断处理机制（lockInterruptibly）。
Lock接口提供了更多的选择，除了能阻塞地获取锁以外，还有tryLock()方法提供非阻塞获取锁的能力，"Boolean tryLock(long time,TimeUnit unit)"提供带超时的获取锁机制，以及lockInterruptibly()提供对中断的响应能力，如果一个线程等待一个锁的过程中（锁被占有)，线程中断了，那么就抛出一个异常InterruptedException。
Synchronized 不可以中断的，非公平的。 Lock，可以判断锁，可以自己设置公平还是不公平。

什么是AQS

AQS（AbstractQueuedSynchronizer） 是一个用来构建锁和同步器的框架，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的 ReentrantLock、CountDownLatch、Semaphore，其他的诸如 ReentrantReadWriteLock，SynchronousQueue，FutureTask 等等皆是基于 AQS 的。当然，我们自己也能利用 AQS 非常轻松容易地构造出符合我们自己需求的同步器。

AQS是一个抽象类，主要是通过继承的方式来使用，它本身没有实现任何的同步接口，仅仅是定义了同步状态的获取以及释放的方法来提供自定义的同步组件。可以这么说，只要搞懂了AQS，那么J.U.C中绝大部分的api都能轻松掌握。

从使用层面来说，AQS的功能分为两种：独占和共享