【2023最新面试题】并发编程

1、谈谈你对AQS的理解

AQS是Abstract Queued Synchronizer的简称，是Java并发编程中比较核心的一个组件。它是一个抽象类，为基于锁和同步状态的框架，为基于锁和同步器的工具提供了一个基础架构。

AQS主要用于实现各种同步组件，如ReentrantLock，Semaphore等等。它提供了两种锁的机制，分别是排它锁和共享锁。排它锁是当存在多个线程去竞争同一共享资源的时候，同一个时刻只允许一个线程去访问这样一个共享资源。共享锁是允许多个线程同时获得这样一个锁的资源。

AQS作为互斥锁需要解决的三个问题：互斥变量的设计，以及如何保证多线程同时更新互斥变量的时候，线程的安全性；未竞争到锁资源的线程的等待；竞争到锁的资源，释放锁之后的唤醒。

AQS的工作原理是一个线程来获取锁资源的时候，首先会判断state是否等于0，也就是说它是无锁状态。如果是，则把这个state更新成1，表示占用到锁。而这个过程中，如果存在同时多次做这样的一个操作，就会导致线程安全性问题。因此AQS采用了CAS机制，去保证state互斥变量更新的一个原子性。未获得到锁的线程通过Unsafe类中的park方法去进行阻塞，把阻塞的线程按照先进先出的原则，去加入到双向链表的一个结构中。当获得锁资源的线程释放锁之后，会从这样一个双向链表的头部去唤醒下一个等待的线程，再去竞争锁。

总的来说，AQS是Java中非常重要的同步工具之一，它提供了一种可扩展的接口，使得使用者可以实现自己的同步组件。AQS的应用非常广泛，主要用于实现各种同步组件，包括锁，倒计时器，信号量，条件变量等等。

2、lock 和 synchronized的区别

Lock和synchronized是Java中两种常见的线程同步机制，它们有以下区别：

实现方式：Lock是接口，而synchronized是关键字。
加锁方式：Lock是显式的加锁，而synchronized是隐式的加锁。
加锁对象：Lock可以作用于代码块上，而synchronized可以作用于方法或代码块上。
底层实现：Lock底层采用AQS（AbstractQueuedSynchronizer）实现，而synchronized底层采用的是objectMonitor实现。
加锁类型：Lock可以是公平锁也可以是非公平锁，而synchronized是非公平锁。
超时机制：Lock中的tryLock可以支持超时机制，而synchronized没有超时机制。
中断机制：Lock中的lockInterruptibly可以支持中断获取锁，而synchronized不支持中断获取锁。
等待队列：Lock有一个同步队列，可以有多个等待队列，而synchronized只有一个同步队列和一个等待队列。
个性化定制：Lock支持个性化定制，采用了模板方法模式，可以自行实现lock方法，而synchronized不支持个性化定制。
总之，Lock和synchronized都有各自的优点和适用场景。在选择使用哪种机制时，需要根据具体的需求和情况来决定。

3、线程池如何知道个线程的任务已经执行完成

线程池本身并不知道线程的任务是否已经执行完成。线程池主要负责管理和调度线程，它并不直接监控线程的任务执行情况。

一般来说，线程池中的每个线程都负责执行一个任务，当任务执行完成后，线程会回到线程池中等待下一个任务的分配。但是，线程池并不直接知道每个线程的任务是否已经执行完成。

如果你需要知道线程的任务是否已经执行完成，你可以通过以下方式来实现：

在任务执行完成时，线程可以向线程池发送一个通知，告知任务已经完成。这可以通过使用线程间的通信机制（如Java中的Future或CountDownLatch）来实现。
在任务执行前，将任务的某些信息（如任务ID或其他标识符）传递给线程池，线程池可以保存这些信息。在任务执行完成后，线程可以将执行结果或其他相关信息传递给线程池，以便线程池进行后续处理。
如果你需要等待所有任务执行完成后再进行后续处理，你可以使用Future.get()方法来阻塞等待任务的完成。当所有任务的Future.get()方法都返回时，意味着所有任务都已经执行完成。
总之，要确定线程的任务是否已经执行完成，你需要根据具体的任务和应用程序需求来设计和实现相应的机制。

1、使用Future和CountDownLatch来通知线程池任务已完成：

import java.util.concurrent.*;  
  
public class ThreadPoolExample {  
    public static void main(String[] args) throws InterruptedException, ExecutionException {  
        ExecutorService executorService = Executors.newFixedThreadPool(10);  
        CountDownLatch latch = new CountDownLatch(1);  
        Future<String> future = executorService.submit(() -> {  
            try {  
                // 模拟任务执行时间  
                Thread.sleep(2000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            // 任务完成时，通知CountDownLatch减少计数  
            latch.countDown();  
            return "Task completed";  
        });  
        latch.await(); // 等待任务完成  
        System.out.println(future.get()); // 获取任务结果  
        executorService.shutdown(); // 关闭线程池  
    }  
}

2、在任务执行前传递任务信息给线程池，任务完成后传递结果给线程池：

import java.util.concurrent.*;  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class ThreadPoolExample {  
    public static void main(String[] args) throws InterruptedException {  
        ExecutorService executorService = Executors.newFixedThreadPool(10);  
        AtomicInteger counter = new AtomicInteger(0);  
        for (int i = 0; i < 10; i++) {  
            int finalI = i;  
            executorService.submit(() -> {  
                // 任务执行前传递任务编号给线程池，可以在这里进行其他初始化工作  
                System.out.println("Task " + finalI + " is running");  
                try {  
                    // 模拟任务执行时间  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                // 任务完成后传递结果给线程池，可以在这里进行其他清理工作  
                counter.incrementAndGet();  
                System.out.println("Task " + finalI + " completed");  
            });  
        }  
        while (counter.get() < 10) {  
            // 在这里等待所有任务完成，可以根据实际情况修改成其他处理方式，比如发送通知或者阻塞等待  
            Thread.sleep(100);  
        }  
        executorService.shutdown(); // 关闭线程池  
    }  
}

4、死锁的四个条件

死锁的四个必要条件包括：

1. 互斥条件：一个资源每次只能被一个进程使用。
2. 占有且等待条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不可强行占有条件：进程已获得的资源，在末使用完之前，不能强行被其他进程剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
   这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

为了避免死锁，可以采取以下措施：

1. 避免使用可重复使用的资源：尽量使用不可重复使用的资源，如临时文件、临时缓冲区等，以减少资源的争用。
2. 避免使用具有相同资源的多个副本：如果多个线程需要使用同一资源，应该使用同一个副本，而不是为每个线程创建多个副本。
3. 对资源使用进行规划：在程序中明确规定每个线程可以使用的资源范围和顺序，以避免产生死锁。
4. 使用锁的顺序：当多个线程需要使用多个锁时，应该按照一定的顺序获取锁，以避免产生死锁。
5. 使用信号量：可以使用信号量来控制对共享资源的访问，避免多个线程同时访问共享资源而产生死锁。
6. 避免长时间持有锁：尽量减少对共享资源的访问时间，以减少死锁的可能性。
7. 检测并解除死锁：可以通过检测死锁的原因和位置，以及解除死锁的方式来避免死锁。例如，可以强制终止一些线程，释放它们占用的资源，从而解除死锁。

总之，避免死锁需要从多个方面入手，包括合理规划资源使用、规定线程访问资源的顺序、使用锁的顺序、信号量的使用以及检测和解除死锁等方面。

5、讲 下wait和 notify 这个为什么要在 synchronized 代码块中?

wait()和notify()是Java中用于线程同步的内置方法，它们通常在synchronized代码块中使用。这是因为它们是用来控制多线程访问共享资源的关键方法。

wait(): 这个方法使当前线程进入等待状态，直到其他线程调用同一个对象的notify()或notifyAll()方法唤醒它。在synchronized代码块中使用wait()可以确保以下几点：

线程安全：通过在synchronized代码块中调用wait()，可以保证当前线程在等待期间不会与其他线程并发访问共享资源，从而避免竞态条件。
对象锁的释放：调用wait()方法会释放当前线程持有的对象锁，允许其他线程进入同步代码块。这有助于实现线程之间的协作和通信。
notify()或notifyAll(): 这两个方法用于唤醒等待在某个对象上的一个或多个线程。在synchronized代码块中使用notify()可以通知等待在该对象上的一个线程，使其从等待状态中恢复并继续执行。同样，notifyAll()方法会唤醒所有在该对象上等待的线程。

使用notify()和notifyAll()的目的是控制多线程对共享资源的访问顺序和条件。通过控制哪个线程先获得对象锁并继续执行，可以避免竞态条件和数据不一致性问题。

总之，wait()和notify()在synchronized代码块中使用是为了确保线程安全和有序地访问共享资源。这样可以避免并发访问导致的数据竞争和不一致问题。

6、你是怎么理解线程安全问题的?

线程安全问题是指在多线程环境下，由于线程之间的相互竞争和并发执行，可能导致资源竞争、数据不一致和不正确结果等问题。线程安全问题通常是由于多个线程同时访问共享资源，例如全局变量、文件、数据库等，并且没有进行正确的同步或互斥处理所导致的。

为了解决线程安全问题，可以采用以下几种方法：

互斥锁：使用互斥锁来确保只有一个线程可以访问共享资源。互斥锁是一种同步机制，当一个线程获取了锁之后，其他线程就不能访问共享资源，直到该线程释放锁。
读写锁：读写锁是一种特殊的锁，用于对共享资源的读操作和写操作进行控制。读写锁可以分为共享锁和独占锁，多个线程可以同时持有共享锁，但只有一个线程可以持有独占锁。
信号量：信号量是一种计数器，用于控制对共享资源的访问次数。信号量的值表示当前可以访问共享资源的最大线程数。
栅栏：栅栏是一种同步机制，用于确保所有线程都到达某个点后再继续执行。栅栏类似于一个屏障，阻止线程继续执行，直到所有线程都到达屏障点。
原子操作：原子操作是不可分割的操作，即在执行过程中不会被其他线程中断。原子操作可以保证对共享资源的操作是原子的，不会出现数据竞争和不一致的问题。
总之，线程安全问题是多线程编程中的重要问题，需要采取适当的同步机制来确保多个线程对共享资源的访问是正确和安全的。

7、什么是守护线程，它有什么特点.

守护线程（Daemon Thread）是一种专门为用户线程提供服务的线程，它的生命周期依赖于用户线程。当JVM中仍然还存在用户线程正在运行的情况下，守护线程才会有存在的意义。否则，一旦JVM进程结束，守护线程也会随之结束。守护线程拥有自己结束自己生命的特性，适合用在一些后台的通用服务场景里面，比如JVM里面的垃圾回收线程等。

守护线程和用户线程的创建方式是完全相同的，只需要调用用户线程里面的setDaemon方法并且设置成true，就表示这个线程是守护线程。但是守护线程不能在线程池或者一些IO任务的场景里面使用，因为一旦JVM退出之后，守护线程也会直接退出，可能导致任务没有执行完或者资源没有正确释放的问题。

public class DaemonThreadExample {  
    public static void main(String[] args) {  
        // 创建一个用户线程  
        Thread userThread = new Thread(new Runnable() {  
            public void run() {  
                // 用户线程的逻辑  
                System.out.println("User thread is running.");  
            }  
        });  
          
        // 将用户线程设置为守护线程  
        userThread.setDaemon(true);  
          
        // 启动用户线程  
        userThread.start();  
          
        // 主线程继续执行其他任务  
        System.out.println("Main thread is running.");  
    }  
}

8、volatile 关键字有什么用? 它的实现原理是什么?

volatile关键字的作用主要有两个：

1、保证内存可见性：在多线程环境中，volatile关键字可以保证每个线程对共享变量的操作都能被正确地反映到主内存中，避免了脏读的问题。
2、禁止指令重排序：volatile关键字可以禁止指令重排序，保证了变量前后代码的执行顺序。

volatile关键字的实现原理是在生成汇编代码时，会在volatile修饰的共享变量进行写操作的时候会多出Lock前缀的指令。Lock前缀的指令会将修改后的变量直接写入主存中，并且将其他线程中该变量的缓存置为无效，从而让其它线程对该变量的引用直接从主存中获取数据，保证了变量的可见性。

然而，volatile关键字无法保证对变量的任何操作都是原子性的。例如，对于自增操作，由于该操作分为读写两个步骤，当一个线程的读操作被阻塞时，另一个线程进行了自增操作，此时主存中可能只加了1。因此，volatile关键字无法替代锁的作用。

9、ThreadLocal 是什么? 它的实现原理呢?

ThreadLocal是一种线程隔离机制，它提供了多线程环境下对于共享变量访问的安全性。ThreadLocal的具体实现原理是，在Thread类里面有一个成员变量ThreadLocalMap，它专门来存储当前线程的共享变量副本，后续这个线程对于共享变量的操作，都是从这个ThreadLocalMap里面进行变更，不会影响全局共享变量的值。

ThreadLocal的使用场景比较多，比如在数据库连接的隔离，对于客户短请求会话的隔离等等。在ThreadLocal中，除了空间换时间的设计思想外，还有一些比较好的设计思想，比如线性探索解决hash冲突，数据预清理机制，若引用key设计尽可能避免内存泄漏等等。

10、ConcurrentHashMap 是如何保证线程安全的?

ConcurrentHashMap是线程安全的哈希表容器，用于在并发环境下操作键值对。它主要通过分段锁技术来实现线程安全。具体来说，ConcurrentHashMap将数据分成不同的区块（Segment），每个区块独立加锁。这种结构使得在执行写操作时，只需锁定当前正在修改的区块，而其他区块仍然可以正常访问，从而大大提高了并发效率。

此外，ConcurrentHashMap在JDK 1.8中的实现方式已经从数组+链表转变为数组+链表/红黑树，进一步优化了其性能。值得注意的是，虽然ConcurrentHashMap提供了原子性的读写操作，但它只保证单个操作的线程安全性，而不保证复合操作的线程安全性。

11、一个空 Obiect 对象的占多大空间

理论上一个空对象占用内存大小只有对象头信息，对象头占12 个字节。 那么ObjA.class 应该占用的存储空间就是12 字节，考虑到8 字节的对齐填充，那么会补上4 字节填充到8 的2倍，总共就是16字节。