【JAVA集合总结-壹】

synchronized 的实现原理以及锁优化？

synchronized 是 Java 中用于实现线程同步的关键字，它确保在同一时刻只有一个线程可以执行特定的代码段。synchronized 的实现原理涉及到 Java 对象头中的 Mark Word 和 Monitor（监视器锁）。
当一个线程访问被 synchronized 修饰的方法或代码块时，它会尝试获取对象的 Monitor 锁。如果锁已经被其他线程持有，则当前线程会阻塞，直到锁被释放。synchronized 可以修饰实例方法、静态方法或代码块，分别对应于对象锁和类锁。
synchronized 的锁优化，可以通过减少锁的粒度、使用并发数据结构、减少锁的持有时间等策略来实现。

ThreadLocal原理，使用注意点，应用场景有哪些？

ThreadLocal 是 Java 中一个非常实用的类，它提供了线程局部变量的功能，每个使用该变量的线程都有独立的变量副本，从而实现了线程间的数据隔离。
ThreadLocal 通过内部类 ThreadLocalMap 来实现，每个线程的 Thread 对象都持有一个 ThreadLocalMap 作为成员变量。ThreadLocalMap 是一个自定义的哈希表，它的键是 ThreadLocal 对象的弱引用，值是线程存储的局部变量。当线程第一次访问 ThreadLocal 变量时，会在 ThreadLocalMap 中创建一个对应的变量副本。ThreadLocal 的 get() 和 set() 方法都是通过操作这个 ThreadLocalMap 来实现的。
使用注意点：
内存泄漏问题：由于 ThreadLocalMap 的键是弱引用，如果 ThreadLocal 没有外部强引用，可能会被垃圾回收，导致 ThreadLocalMap 中出现 null 键的条目，而对应的值无法被回收，从而造成内存泄漏。因此，使用完 ThreadLocal 后应该调用 remove() 方法来清除值。
线程池中的使用：在线程池中使用 ThreadLocal 需要特别小心，因为线程池中的线程是可复用的。如果不清除 ThreadLocal 的值，那么线程可能会在下一次任务中错误地使用上一个任务设置的值。
避免滥用：不应该滥用 ThreadLocal，它主要用于实现线程间的数据隔离，而不是用来传递数据。如果只是为了传递数据，应该优先考虑通过方法参数传递。

synchronized和ReentrantLock的区别？

synchronized 和 ReentrantLock 都是 Java 中用于实现线程同步的手段，它们可以用来确保多个线程在访问共享资源时的一致性和线程安全。尽管它们的目的相同，但在使用和特性上有一些区别：
1.锁的实现方式：
synchronized 是 JVM 层面的锁机制，它可以通过修饰代码块或方法来实现同步。
ReentrantLock 是 Java util.concurrent.locks 包下的一个类，是一个基于 Lock 接口的显式锁机制。
2.锁的公平性：
synchronized 无法指定锁的公平性（Fairness），即无法保证线程获取锁的顺序。
ReentrantLock 可以指定锁的公平性，通过构造函数传入 true 来实现公平锁，以确保线程按照请求锁的顺序来获取锁。
3.锁的可中断性：
synchronized 无法响应中断，一旦一个线程开始等待获取锁，它将一直等待直到获取锁，无法中断。
ReentrantLock 支持可中断的锁获取操作，线程在等待获取锁的过程中可以响应中断。
4.锁的尝试非阻塞：
synchronized 没有提供尝试获取锁的机制，线程只能通过 wait 和 notify 来实现等待/通知机制。
ReentrantLock 提供了 tryLock() 方法，允许线程尝试非阻塞地获取锁，如果锁不可用，线程可以立即返回或者执行其他操作。
5.条件变量：
synchronized 通过 Object 类的 wait() 和 notify() 方法来实现条件变量，这些方法与 synchronized 锁配合使用。
ReentrantLock 提供了 Condition 接口，通过 newCondition() 方法可以创建一个条件变量，提供了比 Object 类更丰富的条件变量操作。
6.锁的可重入性：
synchronized 是可重入的，同一个线程可以多次获取同一把锁。
ReentrantLock 也是可重入的，它的名字（Reentrant）本身就表明了这个特性。
7.锁的实现细节：
synchronized 的锁是基于 JVM 的，它依赖于操作系统的互斥量或监视器锁来实现。
ReentrantLock 的锁是基于 Java 代码实现的，它提供了更灵活的锁机制，但是可能会有更高的性能开销。
性能：
在 Java 6 之后，synchronized 引入了锁粗化、锁消除、轻量级锁和偏向锁等优化，性能有了很大提升。
ReentrantLock 由于是显式锁，它的性能可能受到实现方式的影响，但在某些场景下，由于其提供的灵活性，可能会有更好的性能表现。
总的来说，synchronized 是一种简单且容易使用的同步机制，适合快速实现线程同步的场景。而 ReentrantLock 提供了更丰富的功能和灵活性，适合需要更细粒度控制的场景。在实际开发中，可以根据具体需求选择合适的同步机制。

说说CountDownLatch与CyclicBarrier 区别

CountDownLatch 和 CyclicBarrier 都是 Java 中用于协调多个线程间操作的同步辅助类，它们属于 java.util.concurrent 包。尽管它们的目的相似，都是为了协调线程，但它们的使用场景和工作方式有所不同：
CountDownLatch：
CountDownLatch 是一个同步辅助工具，它允许一个或多个线程等待一组操作完成。
它通过一个计数器来工作，计数器的初始值等于需要等待的操作的数量。
每当一个操作完成时，计数器的值就会减 1。调用 await() 方法的线程会被阻塞，直到计数器的值达到零，此时所有等待的线程都会被释放。CountDownLatch 一旦计数器的值到达零，不能再被重用。如果需要再次使用，必须重新创建一个新的实例。
CyclicBarrier：
CyclicBarrier 允许一组线程相互等待，直到所有线程都到达一个共同的屏障点（Barrier）。
它支持在所有线程都到达屏障点后，可以选择性地执行一个预设的任务（通过 Runnable 参数指定）。
CyclicBarrier 可以被重用，当所有线程都到达屏障点并释放后，可以再次使用它，因此得名“循环”屏障。
它主要用于那些需要多次重复执行相同操作的场景。
以下是它们的主要区别：
一次性 vs 可重复使用：
CountDownLatch 只能使用一次，计数器的值一旦达到零，就不能再重置。
CyclicBarrier 可以重复使用，每次线程们在屏障点释放后，可以再次调用 await() 方法进行下一轮的同步。
目的：
CountDownLatch 通常用于某个线程需要等待其他线程完成工作后才继续执行的场景。
CyclicBarrier 用于控制一组线程，让它们相互等待，直到所有线程都到达某个点，然后一起继续执行。
功能：
CountDownLatch 没有提供在计数器到达零时执行特定任务的功能。
CyclicBarrier 允许在所有线程到达屏障点时执行一个可选的 Runnable 任务。
灵活性：
CountDownLatch 比较简单，只有一个计数器的概念。
CyclicBarrier 提供了更多的控制，包括执行预设任务和查询当前等待的线程数量等。
在实际应用中，选择 CountDownLatch 还是 CyclicBarrier 取决于具体的同步需求。如果需要一次性的同步操作，CountDownLatch 可能更合适；如果需要多次同步操作，CyclicBarrier 可能更有优势。
CountDownLatch案例

 public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 3; i++) {
            Runnable runnable = new Runnable(){

                @Override
                public void run() {
                    try {
                        System.out.println("子线程" + Thread.currentThread().getName() + "开始执行");
                        Thread.sleep(2000);
                        System.out.println("子线程" + Thread.currentThread().getName() + "执行完成");
                        countDownLatch.countDown();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            };
            executorService.execute(runnable);
        }
        try {
            System.out.println("子线程执行完成等待主线程执行：" + Thread.currentThread().getName());
            countDownLatch.await();
            System.out.println("主线程执行：" + Thread.currentThread().getName());
        }catch (Exception e){
            e.printStackTrace();
        }
        

    }

Fork/Join框架的理解

Java 的 Fork/Join 框架是一种用于并行计算的框架，它在 Java 7 中被引入，位于 java.util.concurrent 包中。它主要设计用来分而治之（Divide and Conquer）的并行算法，通过将大任务分解成小任务，然后并行执行这些小任务，最后再将结果合并起来，以此来提高程序的执行效率。

核心组件
ForkJoinTask：是 Fork/Join 框架中的基类，所有并行任务都应该继承这个类。它提供了两个关键方法：fork() 和 join()。fork() 方法用于将任务分解成子任务并异步执行，而 join() 方法用于等待任务完成并获取结果。
RecursiveAction：是一个没有返回结果的 ForkJoinTask 子类，用于执行没有返回值的并行任务。
RecursiveTask：是一个有返回结果的 ForkJoinTask 子类，用于执行有返回值的并行任务。
ForkJoinPool：是一个特殊的线程池，用于管理线程执行 ForkJoinTask 任务。它会自动将任务分解成子任务，并在多个线程中并行执行这些任务。
工作原理
任务分解：将一个大任务分解成多个小任务。这些小任务可以独立执行，并且可以进一步分解。
任务执行：将分解后的小任务提交给 ForkJoinPool 执行。ForkJoinPool 会将任务分配给线程池中的线程执行。
任务合并：当所有子任务完成后，将它们的结果合并起来，形成最终结果。
工作窃取：ForkJoinPool 使用工作窃取算法来提高线程的利用率。当一个线程完成了自己的任务后，它会尝试从其他线程的队列中窃取任务来执行，以此来平衡负载。
使用场景
Fork/Join 框架适用于那些可以分解成多个子任务并且可以并行执行的算法，如：
归并排序：将数组分成两半，分别排序，然后合并。
并行搜索：在大规模数据集中并行搜索元素。
大规模数据处理：如图像处理、大数据分析等。
注意事项
任务分解粒度：需要合理地分解任务，如果任务分解得太细，可能会导致线程切换和任务调度的开销超过并行计算的收益。
线程安全：在设计任务时，需要注意线程安全问题，避免在任务中共享可变状态。
资源限制：并行任务的数量不应该超过系统资源的限制，否则可能会导致系统过载。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class MyRecursiveTask extends RecursiveTask<Integer> {
    private int[] array;
    private int start;
    private int end;

    public MyRecursiveTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= THRESHOLD) {
            // 串行计算
            return computeSerial();
        } else {
            // 分解任务
            int mid = (start + end) / 2;
            MyRecursiveTask subTask1 = new MyRecursiveTask(array, start, mid);
            MyRecursiveTask subTask2 = new MyRecursiveTask(array, mid, end);

            subTask1.fork(); // 异步执行子任务
            int subResult = subTask2.compute(); // 计算右半部分的结果

            int leftResult = subTask1.join(); // 获取左半部分的结果

            return leftResult + subResult; // 合并结果
        }
    }

    private int computeSerial() {
        int sum = 0;
        for (int i = start; i < end; i++) {
            sum += array[i];
        }
        return sum;
    }
}

public class ForkJoinExample {
    public static void main(String[] args) {
        int[] array = { /* 大数组 */ };
        MyRecursiveTask task = new MyRecursiveTask(array, 0, array.length);
        ForkJoinPool pool = new ForkJoinPool();
        Integer result = pool.invoke(task);
        System.out.println("Result: " + result);
    }
}

为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？

为什么调用 start() 方法会执行 run() 方法：
启动新线程：
当你创建一个线程的实例时，它并没有开始执行。调用 start() 方法会告诉 JVM 启动一个新的线程，并在这个新线程中执行 run() 方法。这是线程启动的标准方式。
start() 方法内部调用：
start() 方法内部会调用线程的 run() 方法。这不是直接调用，而是通过线程的执行机制来实现的。start() 方法会请求 JVM 在一个新线程中调度 run() 方法的执行。
线程生命周期：
start() 方法遵循线程的生命周期和状态。当一个线程被启动时，它会被置于就绪状态，等待 CPU 时间片。一旦获得 CPU 时间片，线程就会开始执行 run() 方法。
为什么我们不能直接调用 run() 方法：
无并发：
直接调用 run() 方法不会创建新线程，而是在当前线程中同步执行 run() 方法。这意味着如果你在主线程（通常是 main 方法所在的线程）中直接调用 run() 方法，那么它将不会以并发的方式执行，而是按照普通方法调用的方式执行，这违背了创建线程的初衷。
无法利用多核优势：
直接调用 run() 方法意味着代码仍然是在单线程环境中顺序执行的，无法利用多核处理器的并发处理能力。
线程间协作：
线程提供了一种机制，允许多个任务并发执行，并通过线程间的协作（如 wait()、notify()、join() 等方法）来实现复杂的并发逻辑。直接调用 run() 方法则无法实现这些线程间的协作。
线程调度：
JVM 的线程调度器负责管理线程的执行，包括线程的创建、调度、阻塞、唤醒等。直接调用 run() 方法绕过了 JVM 的线程调度机制，因此无法享受到线程调度带来的优势。

Java中的volatile关键是什么作用？怎样使用它？在Java中它跟synchronized方法有什么不同？volatile 的实现原理

在 Java 中，volatile 是一种轻量级的同步机制，用于确保变量的可见性和有序性。
volatile 的作用
可见性：当一个变量被声明为 volatile 时，它确保对该变量的写操作对所有线程都是立即可见的。这意味着，当一个线程修改了 volatile 变量的值，新值对其他线程来说是立即可见的，无需任何额外的操作。
有序性：volatile 变量的写操作和读操作不会与其他指令重排序。这确保了在访问 volatile 变量时，程序的执行顺序是有序的。
volatile 与 synchronized 的区别
锁的粒度：volatile 是非锁机制，它仅影响变量的可见性和有序性。synchronized 是锁机制，它通过锁定代码块或方法来确保线程安全，提供了更高的安全性，但也可能带来更大的性能开销。
使用场景：volatile 适用于单个变量的读写操作，特别是标志变量，如上面的 running 变量。synchronized 适用于需要原子性操作的场景，如多个变量的操作需要作为一个整体被处理。
性能：volatile 通常比 synchronized 性能更好，因为它不涉及线程的阻塞和唤醒，开销较小。
功能：volatile 只能保证可见性和有序性，不能保证原子性。synchronized 可以保证可见性、有序性和原子性。
volatile 的实现原理
volatile 的实现依赖于底层硬件和 JVM 的内存模型。以下是 volatile 实现的一些关键点：
内存屏障：在 volatile 变量的读写操作中，JVM 会插入内存屏障（Memory Barrier）来防止指令重排序，确保 volatile 变量的读写操作在其他指令之前或之后执行。
缓存一致性：现代处理器使用缓存来提高数据访问速度。volatile 变量的写操作会直接写入主内存，而不是缓存，以确保其他线程能够读取到最新的值。
线程工作内存与主内存：在 Java 内存模型中，每个线程都有自己的工作内存，用于存储主内存中的变量副本。当 volatile 变量被写入时，它会刷新线程的工作内存，确保所有线程都访问主内存中的值。

CAS？CAS 有什么缺陷，如何解决？

CAS（Compare-And-Swap）是一种用于在多线程环境中实现原子操作的机制。它是一种乐观锁，通过比较和交换操作来更新变量值，只有当变量的预期值与当前值相匹配时，才会进行交换操作，从而实现无锁的数据竞争处理。
CAS的工作原理
CAS操作包含三个关键参数：内存位置（V）、预期原值（A）和新值（B）。执行CAS时，如果内存位置的当前值与预期原值相等，那么处理器会自动将该位置值更新为新值。这个过程是原子的，保证了在并发环境下数据的一致性。
CAS的优点
1.非阻塞性：CAS不会使线程挂起，而是通过循环重试的方式尝试更新操作，减少了线程切换的开销。
2.避免死锁：由于CAS不涉及锁的使用，因此不存在死锁的问题。
3.提高性能：在低冲突的情况下，CAS可以显著提高系统的并发性能。
CAS的缺点
1.ABA问题：如果一个值原来是A，变成了B，然后又变回A，CAS无法检测到这种变化，因为它只会检查值是否为A。这可以通过引入版本号来解决，如Java中的AtomicStampedReference。
2.循环时间长开销大：如果CAS操作一直不成功，可能会导致长时间的自旋，消耗CPU资源。Java中的LockSupport类提供了一种机制来减少这种开销。
3.只能保证一个共享变量的原子操作：对多个变量的复合操作无法通过CAS保证原子性。

如何检测死锁？怎么预防死锁？死锁四个必要条件

检测死锁：
1‌‌.图论算法‌：通过构建资源分配图或进程等待图，检测图中是否存在环路，从而判断系统是否出现死锁。这种方法适用于大型系统的复杂情况，但需要一定的计算成本。
‌‌2.系统状态分析‌：通过对系统状态进行分析，检测是否存在进程无法继续执行的情况，从而判断系统是否出现死锁。这种方法适用于动态变化的系统环境，但需要较高的系统资源消耗。
3‌‌.超时机制‌：在进程请求资源时，规定一定的超时时间。如果在规定时间内未能获得资源，则认为进程出现了死锁。这种方法简单易行，但可能会产生误判。
怎么预防死锁：
1.避免资源一次性申请：要求进程在开始执行前一次性申请所有需要的资源，这可以通过资源预先分配来实现。
2.资源有序分配：为所有资源编号，进程必须按照编号顺序来请求资源，这可以防止循环等待条件。
3.使用定时锁：在申请资源时设置超时时间，如果超过时间资源仍未分配，进程释放已占有的资源并重试。
4.资源重分配：在系统运行时，动态地从其他进程中回收资源，然后分配给死锁进程。
5.死锁检测与恢复：定期运行死锁检测算法，一旦发现死锁，采取相应措施恢复，如杀死进程或撤销资源分配。
死锁的四个必要条件：
1.互斥条件：资源不能被多个进程同时使用。
2.占有和等待条件：进程至少持有一个资源，并等待获取其他进程持有的资源。
3.不可抢占条件：已分配给进程的资源不能被强制夺走，只能由占有它的进程自愿释放。
4.循环等待条件：存在一种进程资源的循环等待链，每个进程都在等待下一个进程所占有的资源。

如果线程过多,会怎样?

1.当线程数量过多时，系统可能会遇到一系列的问题和性能瓶颈。以下是线程过多可能导致的一些情况：
2.上下文切换开销增大：线程数量过多会导致频繁的上下文切换，因为操作系统需要在它们之间切换以模拟并发执行。每次上下文切换都会增加CPU的开销，因为需要保存和加载线程的状态。
3.资源竞争加剧：线程间对共享资源（如内存、数据库连接、文件句柄等）的竞争会增加。这可能导致线程阻塞和等待，从而降低程序的整体性能。
4.内存消耗增加：每个线程都需要分配一定的内存空间来存储其执行状态，如程序计数器、寄存器状态和堆栈等。线程数量过多可能会导致内存资源耗尽。
5.响应时间变长：随着线程数量的增加，系统的响应时间可能会变长，因为线程调度和资源分配的延迟增加。
6.系统稳定性下降：线程过多可能会导致系统资源耗尽，如CPU时间、内存和文件描述符等，这可能会影响系统的稳定性，甚至导致系统崩溃。
7.调度开销增大：线程数量的增加意味着调度器需要更多的时间来决定哪个线程应该运行，这会增加调度的开销。
8.死锁风险增加：线程数量越多，它们之间相互作用的可能性就越大，这可能会增加死锁的风险。
9.调试和维护困难：线程过多会使程序的调试和维护变得更加困难，因为开发者需要理解和跟踪更多的执行路径和潜在的并发问题。

说说 Semaphore原理？

Semaphore（信号量）是一种用于控制对有限资源的访问的同步机制。它是一种计数器，用于多线程环境中控制同时访问某个特定资源或资源池的线程数量。信号量可以用来保证线程之间的协调，以避免并发冲突。
信号量的原理
1.计数器：信号量的核心是一个计数器，它表示可用资源的数量。在 Java 中，Semaphore 类通过一个整型变量来维护这个计数器。当前线程请求一个资源，如果计数器的值大于 0，计数器减 1，线程获得资源并继续执行。如果计数器的值为 0，表示没有可用资源，线程将被阻塞，直到其他线程释放资源。
2.公平性：信号量可以是公平的或非公平的。公平性意味着等待时间最长的线程将首先获得资源。非公平信号量则不保证这一点，线程获取资源的顺序是不确定的。
信号量的应用场景
1.限制资源访问：当需要限制对某个资源或资源池的并发访问时，可以使用信号量。例如，限制对数据库连接池的并发访问。
2.控制线程数量：信号量可以用来控制执行某个任务的线程数量。例如，使用固定数量的线程来处理任务队列。
3.任务同步：在某些情况下，需要等待一组任务完成后才能继续执行。信号量可以用来协调这些任务的执行和同步。

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3);

    public void performTask() {
        try {
            semaphore.acquire(); // 请求一个许可证
            try {
                // 执行任务
                System.out.println("Performing task");
                Thread.sleep(1000); // 模拟任务执行时间
            } finally {
                semaphore.release(); // 释放许可证
                System.out.println("Released one permit");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        for (int i = 0; i < 5; i++) {
            new Thread(example::performTask).start();
        }
    }
}

AQS组件，实现原理

AbstractQueuedSynchronizer（AQS）是Java并发包中的一个核心组件，它为构建锁和其他同步器提供了一个有效的框架。AQS使用一个int成员变量来表示同步状态，并通过内置的FIFO（First-In-First-Out）队列来管理线程的排队等待。这个队列实际上是一个双向链表，每个节点代表一个线程。
AQS的核心原理是：
1.同步状态：通过一个volatile修饰的int变量来表示同步状态，通过内置的FIFO队列来管理线程的排队。
2.独占与共享模式：支持独占模式（只有一个线程能执行）和共享模式（多个线程可以同时执行）。
3.模板方法：提供了一些模板方法，如tryAcquire、tryRelease、tryAcquireShared和tryReleaseShared，这些方法需要自定义同步器时实现。
AQS的应用：
AQS广泛应用于Java的并发工具中，如ReentrantLock、Semaphore、CountDownLatch等。这些工具都通过继承AQS并实现其模板方法来完成具体的同步逻辑。
AQS的优势
1.可扩展性：提供了一套通用的同步状态管理和线程排队机制，便于实现各种复杂的同步器。
2.性能：使用CAS操作保证状态修改的原子性，减少了线程竞争，提高了并发性能。
3.简化开发：开发者只需关注同步器的具体逻辑，而无需关心底层的线程排队和状态管理细节。

假设有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？

使用join方法
join方法是Thread类的一个实例方法，它可以让当前线程等待调用join方法的线程执行完成后再继续执行。

public class ThreadOrder {
    public static void main(String[] args) throws InterruptedException {
        Thread T1 = new Thread(() -> {
            System.out.println("T1 is running");
            // 执行T1的任务
        });

        Thread T2 = new Thread(() -> {
            System.out.println("T2 is running");
            // 执行T2的任务
        });

        Thread T3 = new Thread(() -> {
            System.out.println("T3 is running");
            // 执行T3的任务
        });

        T1.start(); // 启动T1
        T1.join();  // 等待T1执行完成

        T2.start(); // 启动T2
        T2.join();  // 等待T2执行完成

        T3.start(); // 启动T3
        // T3会在T2执行完后执行
    }
}

2. 使用CountDownLatch
   CountDownLatch是一个同步助手，它允许一个或多个线程等待其他线程完成操作。

public class ThreadOrder {
    public static void main(String[] args) throws InterruptedException {
        int totalThreads = 3;
        CountDownLatch latch = new CountDownLatch(totalThreads);

        Thread T1 = new Thread(() -> {
            System.out.println("T1 is running");
            try {
                // 执行T1的任务
            } finally {
                latch.countDown(); // 通知完成
            }
        });

        Thread T2 = new Thread(() -> {
            try {
                latch.await(); // 等待T1完成
                System.out.println("T2 is running");
                // 执行T2的任务
            } finally {
                latch.countDown(); // 通知完成
            }
        });

        Thread T3 = new Thread(() -> {
            try {
                latch.await(); // 等待T2完成
                System.out.println("T3 is running");
                // 执行T3的任务
            } finally {
                latch.countDown(); // 通知完成
            }
        });

        T1.start();
        T2.start();
        T3.start();
    }
}

LockSupport作用是？

LockSupport 的作用
1.线程阻塞：LockSupport 允许线程在没有锁定任何对象的情况下被阻塞。这与 Object 类的 wait() 方法不同，后者需要在同步块或方法中调用，并且线程必须持有对象的锁。
2.线程唤醒：LockSupport 允许其他线程唤醒被阻塞的线程。这是通过 LockSupport.unpark(Thread thread) 方法实现的，它将指定的线程从阻塞状态唤醒。
3.线程挂起：LockSupport.park() 方法可以使当前线程挂起，直到另一个线程调用 unpark(Thread thread) 方法来唤醒它，或者当前线程被中断。
4.无锁编程：LockSupport 可以用于构建无锁数据结构和算法，它提供了一种替代传统的锁机制（如 synchronized 或 ReentrantLock）的方法。

public class LockSupportExample {
    private static final LockSupport lockSupport = LockSupport.class.cast(LockSupport::new);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            lockSupport.park();
            System.out.println("Thread 1 is resumed");
        });

        t1.start();

        try {
            Thread.sleep(1000); // 确保t1有足够的时间打印信息
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Thread 1 is about to be unparked");
        lockSupport.unpark(t1);
    }
}

注意事项：
1.使用 LockSupport 时需要注意，过度使用可能会导致线程调度的开销增大。
park() 方法不会释放任何锁，因此它通常用于无锁编程。
2.LockSupport 的 park() 和 unpark() 方法与 Object 类的 wait() 和 notify() 方法相比，提供了更灵活的线程间通信机制。

Condition接口及其实现原理

Condition 接口是 Java 并发包 java.util.concurrent.locks 中的一部分，它提供了一种更灵活的线程间通信机制，通常与 Lock 接口（如 ReentrantLock）一起使用。Condition 允许一个线程在某个条件不满足时挂起，直到其他线程在该条件上发出信号（signal）。
Condition 接口的主要方法包括：
await()：使当前线程等待，直到被通知（signal）或中断。
awaitUninterruptibly()：与 await() 类似，但不响应中断。
signal()：唤醒在该条件上等待的一个线程。
signalAll()：唤醒所有在该条件上等待的线程。
实现原理：
Condition 的实现基于 AbstractQueuedSynchronizer（AQS），一个用于构建锁和其他同步器的框架。当线程调用 await() 方法时，它会释放锁并进入与 Condition 关联的等待队列。当其他线程调用 signal() 或 signalAll() 方法时，等待队列中的一个或所有线程会被移动到锁的同步队列中，从而有机会重新竞争锁。
使用场景：
Condition 适用于需要多路等待/通知的场景，比如生产者-消费者问题。在这种场景下，可以为不同的条件创建不同的 Condition 对象，例如一个用于缓冲区不满，另一个用于缓冲区不空。

Lock lock = new ReentrantLock();
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();

public void put(Object x) throws InterruptedException {
    lock.lock();
    try {
        while (/* 缓冲区满 */) {
            notFull.await();
        }
        // 放置元素到缓冲区
        notEmpty.signal();
    } finally {
        lock.unlock();
    }
}

public Object take() throws InterruptedException {
    lock.lock();
    try {
        while (/* 缓冲区空 */) {
            notEmpty.await();
        }
        // 从缓冲区取出元素
        notFull.signal();
    } finally {
        lock.unlock();
    }
}

说说并发与并行的区别?

并发是指在系统中多个任务交替执行，从而在宏观上看起来是同时执行的。它强调的是任务的交替执行，而不是同时执行。在单个处理器上，通过时间分片（Time Slicing）的方式，让多个任务快速交替执行，给用户一种“同时进行”的错觉。
并行是指在系统中多个任务同时执行。这通常意味着系统具有多个处理器或核心，每个处理器或核心可以独立执行一个任务。
区别：
时间尺度：并发关注在较长时间内任务的执行，而并行关注在某一时刻多个任务的执行。
硬件要求：并行需要硬件支持（如多核处理器），并发则可以在单核处理器上通过操作系统调度实现。
性能提升：并行可以线性提升性能（理论上处理器数量增加多少，性能提升多少），并发的性能提升受限于处理器的时间分片和任务的可并发性。

为什么要用线程池？Java的线程池内部机制，参数作用，几种工作阻塞队列，线程池类型以及使用场景

线程池介绍

如何保证多线程下 i++ 结果正确？

在多线程环境下，对一个变量执行i++操作实际上涉及到多个步骤：读取变量的值、增加值、写回内存。由于这些步骤不是原子的，多个线程同时执行i++可能会导致竞态条件，使得最终的计数值不准确。为了保证i++操作的结果正确，可以使用以下方法：
synchronized关键字：
使用synchronized关键字可以确保只有一个线程能执行i++操作。这可以通过同步代码块或同步方法来实现。

public class Counter {
    private int i = 0;

    public synchronized void increment() {
        i++;
    }

    public synchronized int get() {
        return i;
    }
}

什么是多线程环境下的伪共享（false sharing）？

伪共享（False Sharing）是多线程系统中一个常见的性能问题，它发生在多个线程对位于同一缓存行中的不同变量进行操作时。由于缓存行是缓存系统中数据存储的最小单位，当多个线程修改同一缓存行中的变量，即使这些变量是独立的，也会导致缓存行在处理器之间频繁地无效和同步，从而引发性能下降。
伪共享的影响
伪共享会导致CPU缓存的利用率降低，增加线程同步的开销，并降低程序的可扩展性。在多核处理器系统中，如果多个线程在竞争同一缓存行，它们可能无法充分利用多核处理器的并行处理能力。
避免伪共享的策略
数据布局和分组：合理地布局和分组数据，确保每个线程访问的数据在不同的缓存行上。
缓存行对齐和隔离：使用硬件提供的缓存行对齐和隔离功能，减少线程访问相同缓存行的机会。
优化数据结构和算法：使用合适的数据结构和算法，减少线程访问相同缓存行的机会。
无锁数据结构：使用无锁数据结构减少线程之间的竞争和同步开销。

线程池如何调优，最大数目如何确认？

线程池的调优是一个复杂的过程，它需要根据应用程序的特性和系统资源来进行。以下是一些基本的指导原则和实践：
确认线程池的最大数目：
对于CPU密集型任务，线程数通常设置为CPU核心数加1，因为额外的线程可以在其他线程等待I/O操作时保持CPU的忙碌。
对于IO密集型任务，线程数可以设置得更高，因为线程大部分时间在等待外部资源（如网络或磁盘I/O），增加线程数可以提高并发度和吞吐量。一般建议设置为CPU核心数的2倍或更多。
选择合适的工作队列：
ArrayBlockingQueue：适用于任务数量有限且可控的场景。
LinkedBlockingQueue：适用于任务数量不确定或任务数量很多的场景。
SynchronousQueue：适用于线程数量动态变化的场景，它不存储元素，每个插入操作必须等待另一个线程的移除操作。
设置合理的线程存活时间：
keepAliveTime 应该根据任务的执行时间和系统资源来设置。如果任务执行时间较短，可以设置较短的存活时间来减少资源占用。
选择合适的拒绝策略：
当任务太多无法被线程池及时处理时，拒绝策略决定了如何处理这些额外的任务。常见的拒绝策略包括 AbortPolicy、CallerRunsPolicy、DiscardPolicy 和 DiscardOldestPolicy。
监控和调整：
监控线程池的运行状态，包括活跃线程数、任务队列大小、完成的任务数等，可以帮助调整线程池的参数以适应变化的负载。
避免资源耗尽：
避免设置过高的最大线程数，以免耗尽系统资源。如果线程数过多，可能会导致上下文切换频繁，反而降低性能。
考虑任务特性：
根据任务的特性（如是否是短任务、是否涉及I/O操作等）来调整线程池的参数。
使用工具进行调优：
使用性能分析工具（如JProfiler、VisualVM等）来分析线程池的性能，找出瓶颈并进行调优。
在实际应用中，可能需要多次尝试和调整，才能找到最佳的线程池配置。调优是一个持续的过程，需要根据系统的实际运行情况进行动态调整。

Java 内存模型？

Java 内存模型（Java Memory Model，JMM）是 Java 与操作系统内存模型之间的一个抽象层，它定义了 Java 程序中各种变量的访问规则，以及在多线程环境下如何对变量进行同步。JMM 确保了在多线程环境中，不同线程间的数据访问和操作是可见的、有序的和一致的。
主要概念
主内存（Main Memory）：
主内存是所有线程共享的内存区域，存储了所有的变量（包括实例字段、静态字段等）。
工作内存（Working Memory）：
每个线程都有自己的工作内存，它是主内存的私有拷贝。线程对变量的所有操作（读取、赋值等）首先在工作内存中进行，然后通过一定的机制同步回主内存。
内存可见性（Visibility）：
内存可见性是指当一个线程修改了共享变量的值时，其他线程能够看到这个变更。
原子性（Atomicity）：
原子性是指一个操作或者一系列操作在多线程环境中看起来是不可分割的，要么全部执行，要么全部不执行。
有序性（Ordering）：
有序性是指在多线程环境中，操作的执行顺序对所有线程都是一致的。
同步规则
volatile 关键字：
使用 volatile 关键字声明的变量，保证了对该变量的读写操作对所有线程都是可见的，并且保证从主内存中读取和写入。
synchronized 关键字：
synchronized 可以用于方法或代码块，确保同一时间只有一个线程可以执行同步代码。
final 关键字：
被声明为 final 的变量，一旦初始化完成，其值对所有线程都是可见的。
锁（Locks）：
通过锁机制（如 ReentrantLock），可以对代码块或方法进行同步，保证同一时间只有一个线程可以访问。
原子类（Atomic Classes）：
Java 提供了一系列的原子类（如 AtomicInteger、AtomicLong 等），它们利用 CAS（Compare-And-Swap）操作来保证操作的原子性。
内存屏障
Load Barrier：
确保该屏障之前的所有读操作都完成后，才执行该屏障之后的读操作。
Store Barrier：
确保该屏障之前的所有写操作都完成后，才执行该屏障之后的写操作。
Full Barrier：
同时具有 Load Barrier 和 Store Barrier 的效果。

怎么实现所有线程在等待某个事件的发生才会去执行？

要实现所有线程等待某个事件的发生后再执行，可以使用 Java 中的同步辅助工具，如 CountDownLatch、CyclicBarrier、Semaphore 以及 Object 的 wait() 和 notifyAll() 方法。以下是具体的实现方式：

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " is waiting for the event.");
                    latch.await();
                    System.out.println(Thread.currentThread().getName() + " is running after the event.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        // 模拟事件的发生
        simulateEvent(latch);
    }

    private static void simulateEvent(CountDownLatch latch) {
        System.out.println("Event has occurred!");
        latch.countDown();
    }
}

说一下 Runnable和 Callable有什么区别？

Runnable 和 Callable 都是 Java 中用于创建线程的任务接口，但它们之间存在一些关键的区别：
返回值：
Runnable 接口的 run 方法没有返回值，即它的返回类型是 void。
Callable 接口的 call 方法可以返回一个结果，并且能抛出异常。它的返回类型是 Object，可以通过 Future 获取这个结果。
异常处理：
Runnable 的 run 方法中的异常只能通过内部处理，不能向外抛出。
Callable 的 call 方法可以抛出异常，并且可以通过 Future 获取执行时抛出的异常。
用途：
Runnable 通常用于实现线程任务，它更简单，适用于不需要返回结果的情况。
Callable 通常用于实现可以返回结果的线程任务，它提供了更灵活的线程处理能力。
与 Future 的配合：
Runnable 无法直接与 Future 配合使用，因为 Runnable 本身不返回结果。
Callable 可以与 Future 配合使用，通过 Future 可以获取 Callable 任务的返回值。
线程池提交：
在 Java 的线程池中，可以通过 ExecutorService 接口的 submit 方法提交 Callable 任务，而 execute 方法用于提交 Runnable 任务。

// Runnable 示例
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable task is running.");
        // 执行任务逻辑
    }
}

// Callable 示例
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("Callable task is running.");
        // 执行任务逻辑
        return "Result of the callable task";
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用 Runnable
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();

        // 使用 Callable
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(new MyCallable());
        try {
            // 获取 Callable 任务的结果
            String result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

用Java编程一个会导致死锁的程序，你将怎么解决？

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1 locked lock1");
                try {
                    Thread.sleep(100); // 让 t2 有足够的时间获得 lock2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1 locked lock2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2 locked lock2");
                try {
                    Thread.sleep(100); // 让 t1 有足够的时间获得 lock1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2 locked lock1");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

在这个例子中，两个线程 t1 和 t2 分别尝试以不同的顺序锁定两个对象 lock1 和 lock2。这会导致死锁，因为 t1 持有 lock1 并等待 lock2，而 t2 持有 lock2 并等待 lock1。
下面是一个简单的 Java 程序示例，它会导致死锁：

java
public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1 locked lock1");
                try {
                    Thread.sleep(100); // 让 t2 有足够的时间获得 lock2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1 locked lock2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2 locked lock2");
                try {
                    Thread.sleep(100); // 让 t1 有足够的时间获得 lock1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2 locked lock1");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

在这个例子中，两个线程 t1 和 t2 分别尝试以不同的顺序锁定两个对象 lock1 和 lock2。这会导致死锁，因为 t1 持有 lock1 并等待 lock2，而 t2 持有 lock2 并等待 lock1。
解决死锁的方法：
1.锁定顺序：确保所有线程都以相同的顺序获取锁。
2.锁定时间：尽量减少锁的持有时间，例如，快速完成 synchronized 块内的代码。
3.死锁检测：实现一个算法来检测死锁并进行恢复。这可以通过监控线程和锁的状态来实现。
4.使用定时锁：使用 tryLock() 或 lockInterruptibly() 方法，这些方法在无法获得锁时不会无限期地等待。
5.使用并发工具：使用 java.util.concurrent 包中的并发工具，如 ReentrantLock 或 Semaphore，它们提供了更灵活的锁定机制。
6.避免嵌套锁：尽量避免一个线程持有多个锁，或者确保所有线程释放所有锁后再尝试获取新锁。
7.使用死锁预防算法：如银行家算法，通过分配资源前进行安全性检查来预防死锁。
8.使用超时机制：在尝试获取锁时使用超时机制，例如 tryLock() 方法，这样即使出现死锁，线程也可以在超时后释放已持有的锁并重试。

线程的生命周期，线程的几种状态。

在Java中，线程的生命周期包括几个不同的状态，每个状态代表了线程的某种特定情况。以下是线程的几种状态及其描述：
1.新建状态（New）：
线程对象已经被创建，但还没有调用其 start() 方法。
2.可运行状态（Runnable）：
线程已经调用了 start() 方法，成为可运行状态。在这种状态下，线程可能正在运行，也可能正在等待CPU时间片，因为可运行状态的线程可能会与其他线程共享CPU时间。
3.阻塞状态（Blocked）：
线程因为等待监视器锁（即等待进入同步块或同步方法）而进入阻塞状态。在这种状态下，线程会被挂起，直到获得锁才能进入可运行状态。
4.等待状态（Waiting）：
线程通过调用 wait()、join() 或者 LockSupport.park() 方法进入等待状态。在这种状态下，线程不会被分配CPU执行时间，它们需要被其他线程唤醒或者中断。
5.计时等待状态（Timed Waiting）：
线程通过调用 sleep()、wait(long)、join(long)、LockSupport.parkNanos() 或 LockSupport.parkUntil() 方法进入计时等待状态。与等待状态不同，计时等待状态有明确的最大等待时间。
6.终止状态（Terminated）：
线程的运行结束，这通常是因为线程完成了它的任务（即 run() 方法执行完毕），或者因为某个未捕获的异常导致线程结束。

ReentrantLock实现原理

ReentrantLock 是 Java java.util.concurrent.locks 包下的一个类，它是一个可重入的互斥锁，提供了与 synchronized 关键字类似的同步功能，但带有更多的扩展功能，如尝试非阻塞地获取锁、可中断地获取锁、超时获取锁以及公平性选择等。
ReentrantLock 的实现原理
可重入性：
ReentrantLock 支持可重入锁，即一个线程可以多次获得同一把锁。每次获得锁都会增加锁的持有计数，只有当持有计数减少到零时，锁才会被释放。
锁的获取与释放：
通过 lock() 方法获取锁，如果锁被其他线程持有，则当前线程会被阻塞，直到锁被释放。
通过 unlock() 方法释放锁，这会减少锁的持有计数。
公平性：
ReentrantLock 可以选择公平性（Fairness）。公平锁会按照线程请求锁的顺序来分配锁，而非公平锁则可能允许“插队”现象，从而可能导致某些线程饥饿。
条件变量：
ReentrantLock 提供了条件变量支持，通过 Condition 接口实现。条件变量允许线程在某些条件尚未满足时挂起，并在条件满足时被唤醒。
锁的内部结构：
ReentrantLock 内部使用了一个同步器（Sync 类），它基于 AQS（AbstractQueuedSynchronizer）实现。AQS 是一个用于构建锁和其他同步器的框架，它使用一个整数（状态）来表示同步状态，并使用一个 FIFO 队列来管理线程。
锁的获取方式：
ReentrantLock 提供了多种获取锁的方式，包括可中断地获取锁（lockInterruptibly()）、超时获取锁（tryLock(long timeout, TimeUnit unit)）和尝试非阻塞地获取锁（tryLock()）。
锁的实现细节：
在 ReentrantLock 的实现中，锁的获取和释放涉及到底层的 CAS（Compare-And-Swap）操作，这是一种无锁的原子操作，用于保证状态的原子性更新。
java并发包concurrent及常用的类
wait(),notify()和suspend(),resume()之间的区别