【java并发】Java并发多线程巩固加强（你必须要了解的重点！！）

是瑞穗的猫啊

已于 2023-08-24 11:22:32 修改

阅读量238

点赞数

文章标签： java 开发语言

于 2023-08-17 23:43:50 首次发布

本文链接：https://blog.csdn.net/miles067/article/details/132350398

版权

单例模式双重校验锁变量为什么使用 volatile 修饰？

AutomaticInteger的使用场景

进程和线程的区别，进程间是如何通信的

进程：系统运行的基本单位，进程在运行过程中是相互独立的，但是线程之间运行可以互相影响

线程：独立运行的最小单位，一个进程包含多个线程并且它们共享同一进程内的系统资源

进程之间通过管道、共享内存、信号量机制、消息队列来进行通信

什么是线程上下文切换

当一个线程被剥夺CPU的使用权时，切换到另外一个线程执行

什么是死锁

死锁指的是多个线程在执行过程中，因资源竞争造成的相互等待的情况

死锁的必要条件

死锁需要满足以下四个条件

互斥条件：至少有一个资源同时只能被一个进程（线程）占用，即该资源在一段时间内只能为一个进程（线程）所独占。当一个进程（线程）占用了该资源后，其他进程（线程）不能再访问这个资源，只能等待该进程（线程）释放该资源。
请求与保持条件：一个进程（线程）可以请求获取额外的资源，同时保持已经占有的资源不释放。
不可剥夺条件：已经分配给进程或者线程的资源，不可以强制性的被剥夺
循环等待条件：在相互等待资源的过程中，形成了一个闭环

想要预防死锁，只需要破坏其中一个条件即可，比如使用定时锁、尽量让线程用相同的加锁顺序，还可以用银行家算法可以预防死锁

Synchronized和lock的区别

（1）synchronized是一个关键字，lock是一个类

（2）synchronized在发生异常的时候可以自动释放掉锁，lock则需要手动释放锁

（3）synchronized是可重入锁、非公平锁、不可中断锁

lock的ReentrantLock是可重入锁、可中断锁，（可以是公平锁，也可以设定为不公平锁）

（4）synchronized是JVM通过监视器实现的，Lock是通过AQS实现的

什么是AQS锁

AQS（AbstractQueuedSynchronizer）是Java并发编程中的一个抽象类，位于java.util.concurrent.locks包中。AQS提供了一种实现锁和同步器的框架，可用于构建各种类型的同步工具，如ReentrantLock、CountDownLatch、Semaphore等。

AQS内部通过一个FIFO（先进先出）的队列来管理等待获取同步状态的线程，并提供了一组基本方法来支持子类实现对共享资源的安全访问控制。AQS的核心思想是使用一个整型变量（state）表示共享资源的状态，并通过CAS（Compare and Swap）操作来保证对该变量的原子性操作。

AQS主要提供了以下几个关键方法供子类实现：

acquire(int arg)：尝试获取同步状态，如果获取成功则直接返回，否则将当前线程加入等待队列中。
release(int arg)：释放同步状态，如果释放后唤醒了等待队列中的其他线程，则通知它们重新尝试获取同步状态。
tryAcquire(int arg)：尝试独占方式获取同步状态，成功返回true，失败返回false。
tryRelease(int arg)：尝试独占方式释放同步状态，成功返回true，失败返回false。

为什么AQS使用的是一个双向链表

因为有一些线程可能会出现中断的情况，出现这种情况之后就需要从同步阻塞队列中删除掉，这个时候使用双向链表方便删除中间的节点

有哪些常见的AQS锁

AQS分为独占锁和共享锁

ReentrantLock（独占锁）：可重入（一个线程在持有锁的情况下，可以再次获取同一个锁而不会发生死锁或其他异常情况——就是可以在一个实现功能的递归函数中重复获取同一个锁），可中断，可以是公平锁也可以是非公平锁，非公平锁就是会通过两次CAS去抢占锁，公平锁会按队列顺序排队

Semaphore（信号量）:设定一个信号量，当调用acquire()时判断是否还有信号，有就获取一个信号量，没有就阻塞等待其他线程释放信号量，当调用release()时释放一个信号量，唤醒阻塞线程。

应用场景：允许多个线程访问某个临界资源时，如上下车，买卖票

CountDownLatch（倒计数器）:给计数器设置一个初始值，当调用CountDown()时计数器减一，当调用await() 时判断计数器是否归0，不为0就阻塞，直到计数器为0。（等待多个子线程完成某个任务，然后再继续执行主线程的下一步操作）

应用场景：启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行

CyclicBarrier（循环栅栏）:给计数器设置一个目标值,当调用await() 时会计数+1并判断计数器是否达到目标值，未达到就阻塞，直到计数器达到目标值（一组线程互相等待，直到所有线程都达到某个公共屏障点，然后继续执行下一步操作。）

sleep()和wait()的区别

（1）wait（）是Object的方法，sleep（）是Thread类的方法

（2）wait（）会释放掉锁，sleep（）不会释放掉锁

（3）wait（）要在同步方法或同步代码块中执行，sleep（）方法没有限制

（4）wait（）要用notify（）或notifyAll（）唤醒，sleep（）自动唤醒

yield（）和join的区别

yield（）调用之后线程进入就绪状态

A线程中调用B线程的join（），则B执行完之前A进入阻塞状态

线程池的七大参数

corePoolSize（核心线程数）：线程池中最小的线程数量。即使没有任务需要执行，核心线程也会一直存在。核心线程数通常是线程池能够同时执行的最大任务数。
maximumPoolSize（最大线程数）：线程池中允许存在的最大线程数量。当任务数量超过核心线程数，并且工作队列已满时，线程池可以创建新的线程，但不会超过最大线程数。
keepAliveTime（线程空闲时间）：当线程池中的线程数量超过核心线程数时，多余的空闲线程在被终止之前等待新任务的最长时间。超过这个时间后，多余的线程将被终止，从而减少资源消耗。
unit（时间单位）：用于指定keepAliveTime的时间单位，例如毫秒、秒、分钟等。
workQueue（工作队列）：用于存储提交的任务的队列。当线程池中的线程都在执行任务时，新任务将被添加到工作队列中等待执行。
threadFactory（线程工厂）：用于创建新线程的工厂。可以自定义线程的名称、优先级、是否守护线程等属性。
handler（拒绝策略）：当线程池已经达到最大线程数并且工作队列已满时，新任务无法加入线程池的处理方式。常见的拒绝策略有直接抛出异常、丢弃最早的任务、丢弃最新的任务以及在调用者线程中执行任务。

Java内存模型（JMM）

Java内存模型屏蔽了各种硬件和操作系统的内存访问差异，实现java程序在各平台之下都能达到一致的内存访问效果，它定义了JVM如何将程序中的变量到主存中读取

具体定义为：所有变量都存在主存中，主存是线程共享区域；每个线程都有自己独有的工作内存，线程想要操作变量必须从主从中copy变量到自己的工作区，每个线程的工作内存是相互隔离的

由于主存与工作内存之间有读写延迟，且读写不是原子性操作，所以会有线程安全问题

保证并发安全的三大特性？

原子性：一次或多次操作在执行期间不被其他线程影响

可见性：当一个线程在工作内存修改了变量，其他线程能立刻知道

有序性：JVM对指令的优化会让指令执行顺序改变，有序性是禁止指令重排

volatile关键字

保证变量的可见性和有序性，不保证原子性。使用了 volatile 修饰变量后，在变量修改后会立即同步到主存中，每次用这个变量前会从主存刷新。

单例模式双重校验锁变量为什么使用 volatile 修饰？

当使用双重校验锁（double-checked locking）实现单例模式时，我们需要使用volatile修饰变量。这是因为在多线程环境下，如果不使用volatile修饰变量，可能会导致一个未完全初始化的实例对象被返回。

具体来说，当一个线程第一次访问单例对象时，如果实例对象还没有被初始化，那么该线程会进入同步块，然后再次检查实例对象是否已经被初始化。但是由于JVM存在指令重排序的优化机制，可能会出现以下情况：

线程A进入同步块，创建了一个尚未初始化的实例对象，并将引用指向这个对象。
JVM执行指令重排序，将第3步的初始化操作提前到第2步之前，即在实例对象分配内存后就将引用指向了这块内存，但尚未进行初始化。
线程B也访问单例对象，由于实例对象引用非空，直接返回该对象。
线程A完成对实例对象的初始化。

这样，线程B拿到的实例对象是未完全初始化的，可能会导致错误的结果。

通过使用volatile修饰变量，可以禁止指令重排序，保证在第2步之前，实例对象已经完全初始化。这样，在线程B访问单例对象时，能够获取到一个正确初始化的实例对象。

线程使用方式

（1）继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码逻辑
    }
}

// 创建并启动线程
MyThread thread = new MyThread();
thread.start();

（2）实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码逻辑
    }
}

// 创建并启动线程
Thread thread = new Thread(new MyRunnable());
thread.start();

（3）实现 Callable 接口（带有返回值）：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 线程执行的代码逻辑，可以返回一个结果
        return "Hello, World!";
    }
}

// 创建并启动线程
FutureTask<String> task = new FutureTask<>(new MyCallable());
Thread thread = new Thread(task);
thread.start();

// 获取线程的返回结果
String result = task.get();

（4）使用线程池创建线程：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码逻辑
    }
}

// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务给线程池执行
executor.execute(new MyRunnable());

// 关闭线程池
executor.shutdown();