2025Java面试八股②（含121道面试题和答案）

大G哥

于 2025-06-12 11:40:36 发布

阅读量664

点赞数 16

文章标签：面试 java 职场和发展开发语言

本文链接：https://blog.youkuaiyun.com/Java_fenxiang/article/details/148623579

版权

前面发了60个，这篇把剩下的61个面试题也补上，如果对你有帮忙，收藏不迷路！

61. 装箱和拆箱的原理和作用⭐⭐⭐⭐

装箱和拆箱是指基本类型与其对应的包装类之间的相互转换。装箱和拆箱的引入简化了基本类型与对象类型之间的转换操作。

装箱

装箱是将基本类型转换为其对应的包装类对象的过程。例如，将 int 转换为 integer，将 double 转换为 Double 等。

自动装箱

Java 5 引入了自动装箱功能，使得在需要对象的地方可以自动将基本类型转换为其对应的包装类对象。编译器会自动插入必要的转换代码。

public class Main {
    public static void main(String[] args) {
        int a = 10;
        Integer boxedA = a; // 自动装箱，等价于 Integer boxedA = Integer.valueOf(a);
        System.out.println(boxedA); // 输出 10
    }
}

手动装箱

在没有自动装箱的情况下，可以手动进行装箱操作：

拆箱

拆箱是将包装类对象转换为其对应的基本类型的过程。例如，将 Integer 转换为 int，将 Double 转换为 double 等。

自动拆箱

自动拆箱与自动装箱类似，编译器会在需要基本类型的地方自动将包装类对象转换为基本类型。

public class Main {
    public static void main(String[] args) {
        Integer boxedA = 10; // 自动装箱
        int a = boxedA; // 自动拆箱，等价于 int a = boxedA.intValue();
        System.out.println(a); // 输出 10
    }
}

手动拆箱

在没有自动拆箱的情况下，可以手动进行拆箱操作：

装箱和拆箱的作用

1、自动装箱和拆箱可以减少显式转换的代码，使代码更简洁易读。

2、Java 的集合框架只能存储对象，不能直接存储基本类型。装箱和拆箱使得在集合中使用基本类型变得更加方便。

3、装箱和拆箱允许基本类型和对象类型之间的无缝转换，使得在方法参数、返回值等场景中可以更灵活地处理数据。

性能影响

尽管装箱和拆箱简化了代码，但它们也带来了一些性能上的开销：装箱会创建新的对象，这会带来内存分配和垃圾回收的开销。在拆箱过程中，如果包装类对象为 null，会抛出空指针异常。

62. Enumeration和Iterator接口的区别？⭐⭐

Enumeration和Iterator是 Java 中用于遍历集合的两个接口。虽然它们有相似的功能，但它们有不同的设计和使用方式。

Enumeration接口

Enumeration是一个较老的接口，存在于 Java 1.0 中。它主要用于遍历旧的集合类，如Vector和Hashtable。

常用方法

boolean hasMoreElements(): 如果枚举中仍有更多元素，则返回true。

Object nextElement(): 返回枚举中的下一个元素。

代码 Demo

import java.util.*;
public class EnumerationExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("A");
        vector.add("B");
        vector.add("C");
        Enumeration<String> enumeration = vector.elements();
        while (enumeration.hasMoreElements()) {
            String element = enumeration.nextElement();
            System.out.println(element);
        }
    }
}

Iterator接口

Iterator是在 Java 2 (JDK 1.2) 中引入的。它是集合框架的一部分，适用于所有集合类(如ArrayList、HashSet、HashMap等)。Iterator提供了更灵活的遍历方法，并允许在遍历过程中安全地移除元素。

方法

boolean hasNext(): 如果迭代器中仍有更多元素，则返回true。

E next(): 返回迭代器中的下一个元素。

void remove(): 从集合中移除迭代器返回的最后一个元素(可选操作)。

代码 Demo

import java.util.*;
public class IteratorExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
            if (element.equals("B")) {
                iterator.remove(); // 安全地移除元素
            }
        }
        System.out.println("After removal: " + list);
    }
}

主要区别

接口引入时间：

Enumeration：引入于 Java 1.0。

Iterator：引入于 Java 2 (JDK 1.2)。

方法名称和功能：

Enumeration：使用hasMoreElements()和nextElement()方法。

Iterator：使用hasNext()和next()方法，并增加了remove()方法。

元素移除：

Enumeration：不支持在遍历过程中移除元素。

Iterator：支持在遍历过程中安全地移除元素(通过remove()方法)。

适用范围：

Enumeration：主要用于旧的集合类，如Vector和Hashtable。

Iterator：适用于所有集合类，是集合框架的一部分。

63. java函数参数是值拷贝还是引用拷贝？⭐

在 Java 中，函数参数传递的机制是基于值传递的。

基本类型参数传递

对于基本类型，传递的是值的拷贝。在函数内部对参数的任何修改都不会影响到原始变量。

public class Main {
    public static void main(String[] args) {
        int a = 10;
        modifyValue(a);
        System.out.println(a); // 输出 10
    }

    public static void modifyValue(int x) {
        x = 20;
    }
}

在这个例子中，modifyValue函数内部修改了 x 的值，但这不会影响到 main 函数中的 a。

引用类型参数传递

对于引用类型，传递的也是值的拷贝，但这个值是对象的引用。这意味着在函数内部可以通过引用修改对象的内容，但不能改变引用本身指向的对象。

public class Main {
    public static void main(String[] args) {
        MyObject obj = new MyObject();
        obj.value = 10;
        modifyObject(obj);
        System.out.println(obj.value); // 输出 20
    }

    public static void modifyObject(MyObject o) {
        o.value = 20;
    }
}

class MyObject {
    int value;
}

在这个例子中，modifyObject函数可以通过引用 o 修改 obj 的内容，因此 main 函数中的 obj.value 被修改为 20。

但是，如果试图在函数内部改变引用本身指向另一个对象，这种修改不会影响到原始引用。

public class Main {
    public static void main(String[] args) {
        MyObject obj = new MyObject();
        obj.value = 10;
        changeReference(obj);
        System.out.println(obj.value); // 输出 10
    }

    public static void changeReference(MyObject o) {
        o = new MyObject();
        o.value = 20;
    }
}

class MyObject {
    int value;
}

在这个例子中,changeReference函数试图改变引用 o 指向一个新的对象，但这不会影响到 main 函数中的 obj。

传递的是引用的拷贝，函数内部可以通过引用修改对象的内容，但不能改变引用本身指向的对象。

这种传递机制有时会被误解为“引用传递”，但实际上 Java 中所有参数传递都是值传递。只不过对于引用类型，传递的是引用的值。

64. 基本数据类型和包装类的区别⭐⭐⭐⭐⭐

基本数据类型

Java 中的基本数据类型(也称为原始数据类型)有 8 种：

byte: 8 位，有符号整数，范围 -128 到 127。
short: 16 位，有符号整数，范围 -32,768 到 32,767。
int: 32 位，有符号整数，范围 -2^31 到 2^31-1。
long: 64 位，有符号整数，范围 -2^63 到 2^63-1。
float: 32 位，单精度浮点数。
double: 64 位，双精度浮点数。
char: 16 位，Unicode 字符，范围 0 到 65,535。
boolean: 表示 true 或 false。

包装类

Java 为每种基本数据类型提供了对应的包装类，这些包装类位于java.lang包中：

Byte对应byte
Short对应short
Integer对应int
Long对应long
Float对应float
Double对应double
Character对应char
Boolean对应boolean

65. 什么是fail-fast机制？⭐

在Java集合框架中，fail-fast是一种机制，用于检测在遍历集合时的结构性修改，并立即抛出异常以防止不一致状态。fail-fast迭代器在检测到集合在迭代过程中被修改后，会抛出ConcurrentModificationException异常。

工作原理

fail-fast迭代器通过在遍历集合时维护一个修改计数器(modification count)来工作。每当集合结构发生变化(如添加或删除元素)时，这个计数器就会增加。当创建迭代器时，它会保存当前的修改计数器值。在每次调用next()方法时，迭代器会检查当前的修改计数器值是否与保存的值一致。如果不一致，说明集合在迭代过程中被修改了，迭代器会立即抛出ConcurrentModificationException。

代码 Demo

import java.util.*;
public class FailFastExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
            // 在迭代过程中修改集合
            if (element.equals("B")) {
                list.add("D"); // 这将引发 ConcurrentModificationException
            }
        }
    }
}

在上面的代码中，当迭代器遍历到元素 “B” 时，集合被修改(添加了新元素 “D”)，因此迭代器将抛出ConcurrentModificationException。

注意事项

快速失败并不保证：fail-fast机制并不能保证在所有情况下都能检测到并发修改。它是尽力而为的检测机制，不能依赖于它来实现并发安全。如果需要并发安全的集合，可以使用java.util.concurrent包中的并发集合类。

避免并发修改：在遍历集合时，避免在外部修改集合。可以使用迭代器的remove方法来安全地移除元素。

使用remove方法

为了避免ConcurrentModificationException，可以使用迭代器的remove方法来移除元素：

import java.util.*;
public class SafeRemovalExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
            // 使用迭代器的 remove 方法安全地移除元素
            if (element.equals("B")) {
                iterator.remove();
            }
        }
        System.out.println("After removal: " + list);
    }
}

在这个示例中，使用iterator.remove()方法安全地移除了元素 “B”。

66. 什么是fail-safe机制？⭐

fail-safe机制是与fail-fast机制相对的一种并发处理机制。在 Java 集合框架中，fail-safe迭代器在检测到集合在遍历过程中被修改时，不会抛出异常，而是允许这种修改继续进行。fail-safe迭代器通常是通过在遍历时使用集合的副本来实现的，这样即使原集合被修改，迭代器也不会受到影响。

工作原理

fail-safe迭代器在遍历集合时，实际上是遍历集合的一个副本。因此，任何对原集合的修改都不会影响到迭代器正在遍历的副本。这种机制保证了遍历操作的安全性，但也意味着迭代器不能反映集合的实时变化。

代码 Demo

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Iterator;
public class FailSafeExample {
 publicstaticvoidmain(String[] args) {
     CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
     list.add("A");
     list.add("B");
     list.add("C");
     Iterator<String> iterator = list.iterator();
     while (iterator.hasNext()) {
         Stringelement= iterator.next();
         System.out.println(element);
         // 在迭代过程中修改集合
         if (element.equals("B")) {
             list.add("D"); // 不会引发 ConcurrentModificationException
         }
     }
     System.out.println("After modification: " + list);
 }
}

在上面的代码中，使用CopyOnWriteArrayList作为集合。CopyOnWriteArrayList是一个典型的fail-safe集合类，它在每次修改时都会创建集合的一个副本，因此迭代器不会检测到并发修改，不会抛出ConcurrentModificationException。

主要特点

1. **不抛异常**：fail-safe迭代器在检测到集合被修改时，不会抛出ConcurrentModificationException异常。
  2. **副本遍历**：fail-safe迭代器遍历的是集合的一个副本，而不是原集合。这意味着对原集合的修改不会影响迭代器的遍历。
  3. **线程安全**：fail-safe集合类(如CopyOnWriteArrayList、ConcurrentHashMap等)通常是线程安全的，适用于并发环境。

常见的fail-safe集合类

CopyOnWriteArrayList，ConcurrentHashMap，ConcurrentLinkedQueue，ConcurrentSkipListMap，ConcurrentSkipListSet

注意事项

1. **性能开销**：由于fail-safe机制通常需要创建集合的副本，因此在修改频繁的场景下，性能开销较大。适用于读多写少的场景。
  2. **一致性问题**：由于迭代器遍历的是集合的副本，因此它不能反映集合的实时变化。如果需要实时一致性，fail-safe机制可能不适用。

67. BlockingQueue是什么？⭐

BlockingQueue是 Java 中定义在java.util.concurrent包下的一个接口，它扩展了Queue接口，并添加了阻塞操作。BlockingQueue提供了一种线程安全的机制，用于在多线程环境中处理生产者-消费者问题。

特点和功能

阻塞操作：BlockingQueue提供了阻塞的put和take方法：

put(E e)：如果队列已满，则阻塞直到有空间可插入元素。

take()：如果队列为空，则阻塞直到有元素可取。

线程安全：所有方法都使用内部锁或其他同步机制来确保线程安全。

多种实现：BlockingQueue有多种实现方式，适用于不同的场景：

ArrayBlockingQueue：基于数组的有界阻塞队列。

LinkedBlockingQueue：基于链表的可选有界阻塞队列。

PriorityBlockingQueue：支持优先级排序的无界阻塞队列。

DelayQueue：支持延迟元素的无界阻塞队列。

SynchronousQueue：不存储元素的阻塞队列，每个插入操作必须等待一个对应的移除操作。

LinkedTransferQueue：基于链表的无界阻塞队列，支持传输操作。

代码 Demo

如何使用BlockingQueue实现生产者-消费者模式：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);
        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    System.out.println("Producing: " + i);
                    queue.put(i); // 如果队列已满，阻塞
                    Thread.sleep(100); // 模拟生产时间
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    Integer value = queue.take(); // 如果队列为空，阻塞
                    System.out.println("Consuming: " + value);
                    Thread.sleep(150); // 模拟消费时间
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        consumer.start();
    }
}

LinkedBlockingQueue被用作BlockingQueue的实现。生产者线程不断地向队列中添加元素，而消费者线程不断地从队列中取出元素。如果队列已满，生产者线程会阻塞，直到有空间可插入元素；如果队列为空，消费者线程会阻塞，直到有元素可取。

主要方法

BlockingQueue提供了一些常用的方法，这些方法分为四类：

抛出异常：

add(E e)：如果队列已满，抛出IllegalStateException。

remove()：如果队列为空，抛出NoSuchElementException。

element()：如果队列为空，抛出NoSuchElementException。

返回特殊值：

offer(E e)：如果队列已满，返回false。

poll()：如果队列为空，返回null。

peek()：如果队列为空，返回null。

阻塞操作：

put(E e)：如果队列已满，阻塞直到有空间可插入元素。

take()：如果队列为空，阻塞直到有元素可取。

超时操作：

offer(E e, long timeout, TimeUnit unit)：在指定的时间内插入元素，如果队列已满，等待直到超时或插入成功。

poll(long timeout, TimeUnit unit)：在指定的时间内取出元素，如果队列为空，等待直到超时或取出成功。

68. Java提供了哪些队列？⭐

LinkedList

基于链表实现的双向链表，实现了List、Deque和Queue接口，支持在头部和尾部进行快速插入和删除操作。

使用场景：

需要频繁插入和删除元素的场景。

需要双端队列(Deque)功能的场景，如在头部和尾部进行操作。

PriorityQueue

基于优先级堆(Priority Heap)实现的无界队列。元素按照自然顺序或指定的比较器顺序排列。不允许插入null元素。

使用场景：

需要按优先级处理元素的场景，如任务调度、事件处理等。

需要动态调整元素顺序的场景。

ArrayDeque

基于数组实现的双端队列(Deque)，没有容量限制，可以动态扩展，比LinkedList更高效，尤其是在栈和队列操作方面。

使用场景：

需要高效的栈或队列操作的场景。

需要双端队列功能，但不需要线程安全的场景。

ConcurrentLinkedQueue

基于链表实现的无界非阻塞队列。使用无锁算法，提供高效的并发性能。线程安全，适用于高并发环境。

使用场景：

高并发环境下的无界队列。

需要高效的非阻塞并发操作的场景。

LinkedBlockingQueue

基于链表实现的可选有界阻塞队列，支持阻塞的put和take操作，线程安全，适用于生产者-消费者模式。

使用场景：

生产者-消费者模式，特别是在需要限制队列大小的场景。需要线程安全的阻塞队列。

ArrayBlockingQueue

基于数组实现的有界阻塞队列，必须指定容量，支持阻塞的put和take操作。线程安全，适用于生产者-消费者模式。

使用场景：

生产者-消费者模式，特别是在需要固定大小的队列时。需要线程安全的有界阻塞队列。

DelayQueue

支持延迟元素的无界阻塞队列，元素只有在其延迟时间到期后才能被取出。线程安全，适用于并发环境。

使用场景：

需要延迟处理元素的场景，如任务调度、缓存过期处理等。

定时任务执行场景。

LinkedBlockingDeque

基于链表实现的可选有界阻塞双端队列，支持阻塞的put和take操作。线程安全，适用于生产者-消费者模式。

使用场景：生产者-消费者模式，特别是在需要限制队列大小的双端队列场景。需要线程安全的阻塞双端队列。

69. 阻塞队列原理？⭐

阻塞队列是一种线程安全的队列，它在插入和删除操作上可以阻塞线程，以实现生产者-消费者模式等并发编程需求。阻塞队列的核心原理包括锁机制和条件变量。

基本原理

锁机制

阻塞队列使用锁(如ReentrantLock)来确保线程安全。锁保证了同一时间只有一个线程可以执行插入或删除操作，从而避免并发问题。

条件变量

阻塞队列使用条件变量(Condition)来管理线程的等待和通知。条件变量是与锁关联的，可以在特定条件下阻塞线程并在条件满足时唤醒线程。例如，notEmpty和notFull是常见的条件变量，分别用于表示队列是否为空和是否已满。

等待和通知机制：

当线程试图执行插入操作而队列已满时，它会在notFull条件变量上等待，直到队列中有空闲空间。

当线程试图执行删除操作而队列为空时，它会在notEmpty条件变量上等待，直到队列中有可用的元素。

当插入或删除操作成功后，相应的条件变量会被通知(唤醒)，以便其他等待的线程可以继续执行。

具体实现 Demo

LinkedBlockingQueue是一个基于链表实现的可选有界阻塞队列。它的基本原理如下：

内部结构：使用一个链表来存储元素。使用两个锁：takeLock和putLock，分别用于控制删除和插入操作。使用两个条件变量：notEmpty和notFull，分别用于表示队列是否为空和是否已满。

插入操作(put)：

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        while (count.get() == capacity) {
            notFull.await();
        }
        enqueue(node);
        c = count.getAndIncrement();
        if (c + 1 < capacity) {
            notFull.signal();
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0) {
        signalNotEmpty();
    }
}

删除操作(take)：

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1) {
            notEmpty.signal();
        }
    } finally {
        takeLock.unlock();
    }
    if (c == capacity) {
        signalNotFull();
    }
    return x;
}

等待和通知：

在插入操作中，如果队列已满，线程会在notFull条件变量上等待。

在删除操作中，如果队列为空，线程会在notEmpty条件变量上等待。

插入或删除操作成功后，会相应地通知等待的线程。

70. 重载和重写的区别⭐⭐⭐⭐⭐

重载(Overloading)和重写(Overriding)是面向对象编程中两个重要的概念，它们在方法定义和调用时有不同的用途和规则。

重载

在同一个类中，方法名称相同，但参数列表(参数的类型、数量或顺序)不同的多个方法。

方法名称：相同。

参数列表：必须不同(参数的类型、数量、或顺序)。

返回类型：可以相同也可以不同。

访问修饰符：可以相同也可以不同。

静态/实例方法：都可以重载。

编译时决定：方法的选择在编译时由编译器根据参数列表决定。

重写(Overriding)

在子类中定义一个方法，该方法与父类中的某个方法具有相同的方法名称、参数列表和返回类型，以便在子类中提供该方法的具体实现。

方法名称：相同。

参数列表：必须相同。

返回类型：必须相同(Java 5 及以后可以是协变返回类型，即返回类型可以是父类方法返回类型的子类型)。

访问修饰符：访问级别不能比父类方法更严格(可以更宽松)。

静态/实例方法：只能重写实例方法，不能重写静态方法。

运行时决定：方法的选择在运行时由 JVM 根据对象的实际类型决定(动态绑定)。

总结

重载：发生在同一个类中。方法名称相同，参数列表不同。编译时决定调用哪个方法(静态绑定)。

重写：发生在子类和父类之间。方法名称、参数列表和返回类型必须相同(或协变返回类型)。运行时决定调用哪个方法(动态绑定)。

71. 为什么要使用扰动函数？⭐

扰动函数的目的是为了提高哈希码的质量，使其在哈希表中更均匀地分布。具体来说：

减少哈希冲突：通过将高位和低位混合，扰动函数减少了哈希码的模式性，降低了哈希冲突的概率。

均匀分布：扰动后的哈希码更加均匀地分布在哈希表的桶中，从而提高了哈希表的性能。

示例 Demo

假设我们有一个键对象，其hashCode()返回值为123456。我们可以通过哈希函数计算其哈希值：

调用hashCode()方法：

Plain Text int h = 123456;

扰动函数计算：

Plain Text int hash = h ^ (h >>> 16);

具体计算步骤：

￮ h >>> 16 = 123456 >>> 16 = 1(右移 16 位)

￮ hash = 123456 ^ 1 = 123457(异或运算)

最终，哈希值为123457。

72. 进程、线程、管程、协程区别？⭐⭐⭐

进程 (Process)

进程是操作系统分配资源的基本单位。每个进程都有自己的内存空间、文件描述符、堆栈等资源。

进程的特点

独立性：进程之间是独立的，互不干扰。一个进程的崩溃不会影响其他进程。

资源丰富：每个进程拥有独立的资源，包括内存、文件句柄等。

开销大：创建和销毁进程的开销较大，进程间通信(IPC)也相对复杂。

上下文切换：进程的上下文切换开销较大，因为需要切换内存空间和资源。

使用场景

适用于需要强隔离和独立资源的场景，如独立的服务、应用程序等。

线程 (Thread)

线程是进程内的执行单元，一个进程可以包含多个线程。线程共享进程的资源(如内存空间、文件描述符)。

线程的特点

共享资源：同一进程内的线程共享内存和资源，通信方便。

轻量级：线程的创建和销毁开销较小，上下文切换较快。

并发执行：多线程可以并发执行，提高程序的响应速度和资源利用率。

同步问题：由于共享资源，线程间需要同步机制(如锁)来避免资源竞争和数据不一致。

使用场景

适用于需要并发执行的任务，如多任务处理、并行计算等。

管程 (Monitor)

管程是一种高级的同步机制，用于管理共享资源的并发访问。它将共享资源和访问资源的代码封装在一起，通过条件变量和互斥锁来实现同步。

管程特点

封装性：将共享资源和同步代码封装在一起，提供更高层次的抽象。

互斥访问：通过互斥锁确保同一时刻只有一个线程可以访问共享资源。

条件同步：使用条件变量来协调线程间的执行顺序。

使用场景

适用于需要对共享资源进行复杂同步操作的场景，如操作系统内核、并发数据结构等。

协程 (Coroutine)

协程是一种比线程更轻量级的并发执行单元。协程由程序自身调度，而不是由操作系统内核调度。协程可以在执行过程中主动让出控制权，以便其他协程运行。

协程特点

• 轻量级：协程的创建和切换开销极小，通常在用户态完成。

• 主动让出：协程通过显式的调用(如yield)让出控制权，实现合作式多任务。

• 非抢占式：协程之间的切换是合作式的，不存在抢占问题。

• 栈独立：每个协程有自己的栈，避免了线程间共享栈带来的同步问题。

使用场景

适用于需要大量并发任务且切换频繁的场景，如高并发网络服务器、异步编程等。

虚拟线程 (Virtual Thread)

虚拟线程是一个新概念，特别是在 Java 的 Project Loom 中引入。虚拟线程是一种轻量级线程，由 JVM 管理，旨在简化并发编程并提高并发性能。

特点

轻量级：虚拟线程的创建和销毁开销极小，可以高效地管理数百万个线程。

自动管理：由 JVM 自动调度和管理，不需要开发者显式地管理线程池。

兼容性：与传统的 Java 线程 API 兼容，开发者可以用熟悉的线程模型编写高并发程序。

阻塞操作：虚拟线程可以在阻塞操作(如 I/O 操作)时高效地让出 CPU，而不会浪费资源。

使用场景

适用于高并发应用程序，如高性能服务器、Web 应用等。

73. 用户线程与守护线程区别⭐⭐⭐

用户线程

用户线程是应用程序创建的普通线程，也称为非守护线程。当所有用户线程都结束时，Java 虚拟机 (JVM) 也会退出。

特点

生命周期：用户线程的生命周期由应用程序控制。只要有一个用户线程在运行，JVM 就会继续运行。

重要性：用户线程通常用于执行应用程序的主要任务，例如处理业务逻辑、执行计算等。

关闭 JVM：JVM 只有在所有用户线程都结束后才会退出，即使还有守护线程在运行。

使用场景

适用于需要执行重要任务且不能中途被终止的线程。例如：处理用户请求的线程，执行关键业务逻辑的线程

守护线程 (Daemon Thread)

守护线程是为其他线程提供服务和支持的线程。当所有非守护线程(用户线程)都结束时，JVM 会自动退出，即使守护线程还在运行。

特点

生命周期：守护线程的生命周期依赖于用户线程。当所有用户线程结束时，守护线程也会自动终止。

后台任务：守护线程通常用于执行后台任务，如垃圾回收、日志记录等。

低优先级：守护线程通常优先级较低，因为它们主要为用户线程提供支持。

使用场景

适用于执行后台任务或辅助任务的线程，这些任务不需要在 JVM 退出时完成。例如：JVM 的垃圾回收线程，日志记录线程，监控和统计线程

代码 Demo

public class ThreadExample {
    public static void main(String[] args) {
        Thread userThread = new Thread(() -> {
            try {
                Thread.sleep(5000);
                System.out.println("User thread finished");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread daemonThread = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                    System.out.println("Daemon thread running");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        daemonThread.setDaemon(true);
        userThread.start();
        daemonThread.start();
        System.out.println("Main thread finished");
    }
}

在这个例子中：

userThread是一个用户线程，它会运行 5 秒钟。daemonThread是一个守护线程，它会每秒钟打印一次消息。

当userThread结束后，JVM 会退出，即使daemonThread还在运行。

74. Java线程的创建方式？⭐⭐⭐⭐⭐

继承Thread类

通过继承java.lang.Thread类并重写其run方法来创建线程。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

实现Runnable接口

通过实现java.lang.Runnable接口并将其传递给Thread对象来创建线程。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

实现Callable接口和使用FutureTask

通过实现java.util.concurrent.Callable接口来创建线程，并使用FutureTask来管理返回结果。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            System.out.println("Result: " + futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池

通过java.util.concurrent.ExecutorService创建和管理线程池，避免手动创建和管理线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("Thread pool task is running");
            });
        }
        executorService.shutdown();
    }
}

使用Lambda表达式 (Java 8及以上)

通过Lambda表达式简化Runnable接口的实现。

public class LambdaExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> System.out.println("Lambda thread is running"));
        thread.start();
    }
}

75. Java线程的几种创建方式有什么区别？⭐⭐⭐⭐⭐

继承Thread类

通过继承Thread类并重写run方法。适合快速创建简单的线程任务。缺点就是Java不支持多继承，如果你的类已经继承了另一个类，就不能再继承Thread。同时不适合复杂的线程管理和资源共享场景。

实现Runnable接口

通过实现Runnable接口并将其传递给Thread对象。适合需要共享资源或任务的场景。可以实现多个接口，增加了灵活性。多个线程可以共享同一个Runnable实例，方便资源共享和任务分配。

实现Callable接口和使用FutureTask

实现Callable接口来创建线程，并使用FutureTask来管理返回结果。适合需要返回结果的并发任务，可以返回任务执行结果。同时可以抛出异常，便于异常处理。相比Runnable，实现和使用稍微复杂一些。

使用线程池

通过ExecutorService来创建和管理线程池，适合需要管理大量线程的场景。减少了频繁创建和销毁线程的开销。更好地管理系统资源，防止资源耗尽。可以根据任务量动态调整线程池大小。

76. Java多线程优先级是什么？⭐⭐

在Java中，每个线程都有一个优先级，优先级决定了线程调度器对线程的调度顺序。线程的优先级是一个整数值，范围在1到10之间。

最低优先级：Thread.MIN_PRIORITY(值为1)

默认优先级：Thread.NORM_PRIORITY(值为5)

最高优先级：Thread.MAX_PRIORITY(值为10)

线程优先级的作用

线程优先级是对线程调度器的一种建议，调度器会根据优先级来决定哪个线程应该优先执行。然而，线程优先级并不能保证线程一定会按照优先级顺序执行，具体的调度行为依赖于操作系统的线程调度策略。

设置线程优先级

可以通过setPriority(int newPriority)方法来设置线程的优先级。需要注意的是，设置的优先级必须在1到10之间，否则会抛出IllegalArgumentException。

public class ThreadPriorityExample {
 public static void main(String[] args) {
     Thread lowPriorityThread = new Thread(() -> {
         for (int i = 0; i < 5; i++) {
             System.out.println("Low priority thread running");
         }
     });
     lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
     Thread highPriorityThread = new Thread(() -> {
         for (int i = 0; i < 5; i++) {
             System.out.println("High priority thread running");
         }
     });
     highPriorityThread.setPriority(Thread.MAX_PRIORITY);
     lowPriorityThread.start();
     highPriorityThread.start();
 }
}

我们创建了两个线程，一个设置为最低优先级，一个设置为最高优先级。通常情况下，系统会优先调度高优先级的线程执行，但这并不是绝对的，具体行为依赖于操作系统的调度策略。

注意事项

1. **优先级并不保证执行顺序**：线程优先级只是对线程调度器的一个建议，不能保证线程会按照优先级顺序执行。
  2. **避免滥用优先级**：不建议过度依赖线程优先级来控制线程的执行顺序，应该更多地通过设计合理的并发控制机制(如锁、信号量、条件变量等)来管理线程。
  3. **平台依赖性**：不同操作系统对线程优先级的支持和实现方式可能不同，因此在跨平台应用中，优先级的效果可能不一致。

77. Java多线程的生命周期是什么⭐⭐⭐⭐

在Java中，线程的生命周期包括多个状态，每个状态表示线程在其生命周期中的不同阶段。线程的生命周期状态主要包括：

新建(New)
就绪(Runnable)
运行(Running)
阻塞(Blocked)
等待(Waiting)
超时等待(Timed Waiting)
终止(Terminated)

线程状态详解

新建(New)

当一个线程对象被创建时(例如，通过new Thread())，线程处于新建状态。此时，线程还没有开始运行。

就绪(Runnable)

当调用start()方法后，线程进入就绪状态。线程在就绪状态下等待操作系统的线程调度器将其调度到CPU上执行。注意：在Java中，Runnable状态包括了运行状态(Running)，即线程可以运行，也可能正在运行。

运行(Running)

当线程获得CPU时间片并开始执行其run()方法时，线程进入运行状态。线程在这个状态下实际执行任务。

阻塞(Blocked)

线程在等待一个监视器锁(monitor lock)时进入阻塞状态。例如，线程试图进入一个synchronized方法或块，但其他线程已经持有了该对象的锁。

等待(Waiting)

线程无限期地等待另一个线程显式地唤醒它时进入等待状态。例如，调用Object.wait()方法，或者Thread.join()方法(不带超时时间)，或者LockSupport.park()方法。

超时等待(Timed Waiting)

线程在等待另一个线程显式地唤醒它，或者等待特定的时间段后自动唤醒时进入超时等待状态。例如，调用Thread.sleep(long millis)方法，Object.wait(long timeout)方法，Thread.join(long millis)方法，或者LockSupport.parkNanos(long nanos)方法。

终止(Terminated)

当线程的run()方法执行完毕或者抛出未捕获的异常时，线程进入终止状态。线程在这个状态下不再执行任何任务。

78. 为什么java多线程调用的是start方法不是run方法？⭐⭐⭐⭐

start()方法

start()方法的作用是启动一个新线程，并且使该线程进入就绪状态，等待操作系统的线程调度器来调度它执行。当你调用start()方法时，Java虚拟机会创建一个新的执行线程。在这个新的线程中，Java虚拟机会自动调用run()方法。调用start()方法后，原来的线程和新创建的线程可以并发执行。

run()方法

run()方法包含了线程执行的代码，是你需要在新线程中执行的任务。如果直接调用run()方法，run()方法会在当前线程中执行，而不会启动一个新线程。直接调用run()方法不会创建新的线程，所有代码在调用run()方法的线程中顺序执行。

代码 Demo

public class MyThread extends Thread {
 @Override
 public void run() {
     System.out.println("Thread is running");
 }
 public static void main(String[] args) {
     MyThread thread = new MyThread();
     // 调用 start() 方法
     thread.start(); // 这会启动一个新线程，run() 方法在新线程中执行
     // 调用 run() 方法
     thread.run(); // 这会在当前线程中执行 run() 方法，不会启动新线程
 }
}

为什么不能直接调用run()方法

1. **启动新线程**：start()方法负责启动一个新线程，而直接调用run()只是普通的方法调用，不会启动新线程。
  2. **并发执行**：通过start()方法启动的新线程可以与原来的线程并发执行，而直接调用run()方法则是在当前线程中顺序执行。
  3. **线程状态管理**：start()方法会使线程进入就绪状态，等待操作系统调度，而直接调用run()方法不会改变线程的状态管理。

79. 线程的基本方法⭐⭐⭐⭐⭐

start()

start()方法用于启动线程。线程创建以后，并不会自动运行，需要我们调用start()，将线程的状态设为就绪状态，但不一定马上就被运行，得等到CPU分配时间片以后，才会运行

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}
public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();  // 启动新线程
    }
}

注意：直接调用run()方法不会启动新线程，而是在当前线程中执行run()方法。

run()

run()方法包含线程执行的代码。它是Thread类和Runnable接口的核心方法。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}
public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();  // 启动新线程，实际调用的仍是 run() 方法
    }
}

sleep(long millis)

sleep(long millis)方法使当前线程休眠指定的毫秒数。它会抛出InterruptedException，因此需要处理该异常。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                System.out.println("Thread is sleeping");
                Thread.sleep(1000);  // 休眠1秒
                System.out.println("Thread woke up");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
    }
}

join()

join()方法等待线程终止。调用该方法的线程会等待被调用线程执行完毕后再继续执行。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);  // 模拟工作
                System.out.println("Thread finished");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();

        try {
            t1.join();  // 等待 t1 线程结束
            System.out.println("Main thread continues");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

interrupt()

interrupt()方法用于中断线程。被中断的线程会抛出InterruptedException。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("Thread is running");
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted");
            }
        });
        t1.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t1.interrupt();  // 中断 t1 线程
    }
}

isInterrupted()

isInterrupted()方法用于检查线程是否被中断。它返回一个布尔值。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("Thread is interrupted");
                    break;
                }
                System.out.println("Thread is running");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();  // 重新设置中断状态
                }
            }
        });
        t1.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t1.interrupt();  // 中断 t1 线程
    }
}

setPriority(int newPriority)

setPriority(int newPriority)方法用于设置线程的优先级。优先级范围从Thread.MIN_PRIORITY(1) 到Thread.MAX_PRIORITY(10)，默认优先级为Thread.NORM_PRIORITY(5)。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread is running with priority: " + Thread.currentThread().getPriority());
        });
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
    }
}

getPriority()

getPriority()方法用于获取线程的优先级。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread priority: " + Thread.currentThread().getPriority());
        });
        t1.start();
    }
}

setName(String name)

setName(String name)方法用于设置线程的名称。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread name: " + Thread.currentThread().getName());
        });
        t1.setName("MyThread");
        t1.start();
    }
}

getName()

getName()方法用于获取线程的名称。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread name: " + Thread.currentThread().getName());
        });
        t1.start();
    }
}

currentThread()

currentThread()方法用于获取当前正在执行的线程。

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            Thread currentThread = Thread.currentThread();
            System.out.println("Current thread: " + currentThread.getName());
        });
        t1.start();
    }
}

80. sleep和wait方法的区别⭐⭐⭐⭐

Thread.sleep()和Object.wait()是Java中用于控制线程行为的两种方法，但它们有着显著的区别。

区别

	sleep 方法	object.wait 方法
定义	Thread.sleep(long millis)是一个静态方法，属于Thread类。	wait()是一个实例方法，属于Object类。
作用	使当前线程进入休眠状态，暂停执行一段时间(以毫秒为单位)。	使当前线程等待，直到另一个线程调用该对象的notify()或notifyAll()方法来唤醒它。
锁状态	调用sleep方法时，线程不会释放它所持有的任何锁。	调用wait方法时，线程必须持有该对象的监视器锁，并且会释放该锁，进入等待状态。
唤醒	在指定的时间到期后，线程会自动从休眠状态中醒来并继续执行，不需要其他线程显式唤醒它。	线程必须被其他线程显式唤醒，调用notify()或notifyAll()方法，或者在超时等待的情况下，时间到期后自动唤醒。
异常	sleep方法会抛出InterruptedException，如果线程在休眠期间被中断。	wait方法会抛出InterruptedException，如果线程在等待期间被中断。
场景	通常用于暂停线程的执行，模拟延迟或让出CPU时间片。	通常用于线程间通信，协调线程之间的执行顺序。

Thread.sleep()示例

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread is going to sleep");
                Thread.sleep(2000); // 休眠2秒
                System.out.println("Thread woke up");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread.start();
    }
}

Object.wait()示例

public class WaitNotifyExample {
    private static final Object lock = new Object();
    public static void main(String[] args) {
        Thread waitingThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread is waiting");
                    lock.wait(); // 进入等待状态，并释放锁
                    System.out.println("Thread is resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread notifyingThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(2000); // 休眠2秒
                    System.out.println("Thread is going to notify");
                    lock.notify(); // 唤醒等待线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        waitingThread.start();
        notifyingThread.start();
    }
}

81. 介绍一下常用的java的线程池？⭐⭐

FixedThreadPool(固定大小线程池)

线程池中有固定数量的线程。无论有多少任务提交，线程池中的线程数量始终不变。当所有线程都处于忙碌状态时，新的任务将会在队列中等待。适用于负载较均衡的场景，任务数量相对稳定。

Plain Text ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads);

CachedThreadPool(缓存线程池)

线程池中线程数量不固定，可以根据需要自动创建新线程。如果线程池中的线程在60秒内没有被使用，则会被终止并从池中移除。当提交新任务时，如果没有空闲线程，则会创建新线程。适用于执行很多短期异步任务的小程序，或者负载较轻的服务器。

Plain Text ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

SingleThreadExecutor(单线程池)

线程池中只有一个线程，所有任务按照提交的顺序执行。确保所有任务在同一个线程中按顺序执行。适用于需要保证顺序执行任务的场景。

Plain Text ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

ScheduledThreadPool(定时线程池)

线程池可以在给定延迟后运行任务，或者定期执行任务。类似于Timer类，但更灵活且功能更强大。适用于需要周期性执行任务的场景。

Plain Text ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

WorkStealingPool(工作窃取线程池)

使用多个工作队列减少竞争，适用于并行计算。线程池中的线程数量是Runtime.getRuntime().availableProcessors()的返回值。适用于需要大量并行任务的场景。

Plain Text ExecutorService workStealingPool = Executors.newWorkStealingPool();

82. Java线程池的原理⭐⭐⭐⭐

Java线程池是一种管理和复用线程的机制，旨在提高应用程序的性能和资源利用效率。线程池通过减少线程创建和销毁的开销来提高系统的响应速度和吞吐量，并且可以有效管理和控制线程的数量，防止过多的线程导致系统资源耗尽。

线程池的基本原理

线程复用：线程池在初始化时创建一定数量的线程，这些线程在任务执行完毕后不会被销毁，而是被回收并重新用于执行新的任务。
任务队列：当所有线程都在忙碌时，新提交的任务会被放入任务队列中，等待空闲线程来执行。
线程管理：线程池可以根据需要动态调整线程的数量，创建新线程或销毁空闲线程，以应对任务量的变化。
资源控制：通过限制线程的数量，线程池可以防止系统资源(如CPU、内存)被过度消耗。

83. 使用线程池的好处⭐⭐⭐⭐⭐

提高性能和响应速度

减少线程创建和销毁的开销：每次创建和销毁线程都需要消耗系统资源。线程池通过复用线程，减少了这些开销，从而提高了系统的性能和响应速度。

快速响应任务：线程池中已有的线程可以立即执行新任务，而不需要等待新的线程创建完成。

更好的资源管理

控制并发线程的数量：线程池可以限制并发执行的线程数量，防止系统资源(如CPU、内存)被过度消耗，避免由于过多线程导致的资源耗尽。

任务排队：线程池内部维护一个任务队列，当所有线程都在忙碌时，新任务会被放入队列中等待执行，这样可以平滑地处理任务高峰。

简化并发编程

简化线程管理：开发者不需要手动创建、管理和销毁线程，减少了并发编程的复杂性和出错的可能性。

统一的任务提交接口：通过统一的接口(如execute和submit方法)提交任务，简化了任务管理和执行。

提高系统稳定性

避免资源枯竭：通过限制线程数量和任务队列长度，线程池可以防止系统资源被耗尽，从而提高系统的稳定性和可靠性。

拒绝策略：线程池提供了多种拒绝策略(如AbortPolicy、CallerRunsPolicy等)，可以灵活处理任务队列已满时的新任务，避免系统崩溃。

更好的性能监控和调优

线程池监控：通过ThreadPoolExecutor提供的监控方法(如getPoolSize、getActiveCount、getCompletedTaskCount等)，可以方便地监控线程池的状态和性能。

调优参数：线程池提供了多个参数(如核心线程数、最大线程数、空闲线程存活时间等)，可以根据具体应用场景进行调优，以达到最佳性能。

84. 线程池的核心构造参数有哪些？⭐⭐⭐⭐⭐

构造参数

corePoolSize(核心线程数)

线程池中始终保持运行的最小线程数，即使这些线程处于空闲状态也不会被销毁。当提交一个新任务时，如果当前运行的线程数少于corePoolSize，即使有空闲线程，也会创建一个新线程来处理任务。

maximumPoolSize(最大线程数)

线程池允许创建的最大线程数。当任务队列已满且当前运行的线程数小于maximumPoolSize时，会创建新线程来执行任务。

keepAliveTime(线程空闲时间)

当线程池中的线程数超过corePoolSize时，多余的空闲线程在等待新任务的最大时间。超过这个时间后，这些空闲线程将被终止。

unit(时间单位)

keepAliveTime参数的时间单位。可以是TimeUnit枚举中的任意值，如TimeUnit.SECONDS、TimeUnit.MILLISECONDS等。

workQueue(任务队列)

用于保存等待执行的任务的队列。常用的队列实现包括：

LinkedBlockingQueue：一个基于链表的无界队列。

ArrayBlockingQueue：一个基于数组的有界队列。

SynchronousQueue：一个不存储元素的队列，每个插入操作必须等待一个对应的移除操作。

PriorityBlockingQueue：一个支持优先级排序的无界队列。

threadFactory(线程工厂)

用于创建新线程的工厂。可以通过自定义线程工厂来设置线程的名称、优先级等属性。默认实现是Executors.defaultThreadFactory()。

handler(拒绝策略)

当任务队列已满且线程数量达到最大线程数时，新的任务会被拒绝执行。拒绝策略定义了这种情况下的处理方式。

常用的拒绝策略包括：

AbortPolicy：抛出RejectedExecutionException，默认策略。

CallerRunsPolicy：由调用线程执行任务。

DiscardPolicy：丢弃任务，不抛出异常。

DiscardOldestPolicy：丢弃队列中最旧的任务，然后重新尝试提交新任务。

代码 Demo

暂时无法在飞书文档外展示此内容

参数调优

1. **corePoolSize 和 maximumPoolSize**：根据应用的具体需求和系统资源进行设置。对于CPU密集型任务，可以设置较小的核心线程数；对于I/O密集型任务，可以设置较大的核心线程数。
  2. **keepAliveTime 和 unit**：通常设置为较长的时间，以便在任务高峰期过后，线程池能够回收多余的线程。
  3. **workQueue**：选择合适的队列类型和大小。对于任务量较大的场景，可以使用无界队列；对于需要限制任务队列长度的场景，可以使用有界队列。
  4. **threadFactory**：如果需要自定义线程属性(如名称、优先级等)，可以实现一个自定义的ThreadFactory。
  5. **handler**：根据应用的容错需求选择合适的拒绝策略。对于关键任务，可以使用CallerRunsPolicy或自定义拒绝策略。

85. Java 线程池工作过程？⭐⭐

线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
当调用 execute() 方法添加一个任务时，线程池会做如下判断：

a) 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；

b) 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；

c) 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；

d) 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常 RejectExecutionException。

当一个线程完成任务时，它会从队列中取下一个任务来执行。
当一个线程无事可做，超过一定的时间(keepAliveTime)时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

86. 如何重构一个线程工厂⭐⭐

为什么要使用线程工厂

统一管理线程创建：通过集中管理线程的创建过程，可以确保所有线程具有一致的属性设置，如名称、优先级和是否为守护线程。

增强可维护性：将线程创建逻辑从业务代码中分离出来，使代码更清晰、更易维护。

提高可扩展性：通过自定义线程工厂，可以轻松添加新的功能，例如日志记录、异常处理和线程组管理。

基本的线程工厂实现

默认的线程工厂实现(Executors.defaultThreadFactory())创建的线程没有特别的属性设置。可以通过实现ThreadFactory接口来定制线程的创建过程。

实现ThreadFactory接口：定义一个类实现ThreadFactory接口，并重写newThread方法。
设置线程属性：在newThread方法中，创建新的线程并设置其属性，如名称、优先级和是否为守护线程。

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
public class CustomThreadFactory implements ThreadFactory {
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    private final boolean daemon;
    private final int priority;
    public CustomThreadFactory(String namePrefix, boolean daemon, int priority) {
        this.namePrefix = namePrefix;
        this.daemon = daemon;
        this.priority = priority;
    }
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r, namePrefix + "-thread-" + threadNumber.getAndIncrement());
        thread.setDaemon(daemon);
        thread.setPriority(priority);
        return thread;
    }
}

扩展和优化线程工厂

为了使线程工厂更加强大和灵活，我们可以添加更多功能。例如：

日志记录

记录每个线程的创建过程，便于调试和监控。

import java.util.logging.Level;
import java.util.logging.Logger;
public class EnhancedThreadFactory extends CustomThreadFactory {
    private static final Logger logger = Logger.getLogger(EnhancedThreadFactory.class.getName());
    public EnhancedThreadFactory(String namePrefix, boolean daemon, int priority) {
        super(namePrefix, daemon, priority);
    }
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = super.newThread(r);
        logger.log(Level.INFO, "Created new thread: {0}", thread.getName());
        return thread;
    }
}

线程组管理

将线程归类到特定的线程组中，便于管理和控制。

public class GroupedThreadFactory extends CustomThreadFactory {
    private final ThreadGroup group;
    public GroupedThreadFactory(String namePrefix, boolean daemon, int priority, ThreadGroup group) {
        super(namePrefix, daemon, priority);
        this.group = group;
    }
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(group, r, namePrefix + "-thread-" + threadNumber.getAndIncrement());
        thread.setDaemon(daemon);
        thread.setPriority(priority);
        return thread;
    }
}

使用自定义线程工厂

通过自定义的线程工厂创建线程池，确保线程具有一致的属性设置。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadFactoryExample {
    public static void main(String[] args) {
        CustomThreadFactory threadFactory = new CustomThreadFactory("CustomPool", false, Thread.NORM_PRIORITY);
        ExecutorService executorService = Executors.newFixedThreadPool(5, threadFactory);
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                String threadName = Thread.currentThread().getName();
                System.out.println("Hello from " + threadName);
            });
        }
        executorService.shutdown();
    }
}

87. 线程池的拒绝策略有哪些？⭐⭐

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时，如果还有任务到来就会采取任务拒绝策略，线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。

Java的java.util.concurrent包中提供了几种内置的拒绝策略，通过实现RejectedExecutionHandler接口来定义它们。以下是几种常见的拒绝策略：

AbortPolicy(默认策略)

抛出RejectedExecutionException异常，通知调用者任务被拒绝。

CallerRunsPolicy

由调用线程(提交任务的线程)直接运行被拒绝的任务。这种策略提供了一种简单的反馈机制，减缓提交任务的速度。

DiscardPolicy

直接丢弃被拒绝的任务，不做任何处理，也不抛出异常。

DiscardOldestPolicy

丢弃最早提交的未处理任务，然后重新尝试执行当前被拒绝的任务。

自定义拒绝策略

除了内置的拒绝策略，还可以通过实现RejectedExecutionHandler接口来定义自己的拒绝策略。

public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 自定义的拒绝处理逻辑
        System.out.println("Task " + r.toString() + " rejected");
    }
}
// 使用自定义拒绝策略
RejectedExecutionHandler handler = new CustomRejectedExecutionHandler();

使用拒绝策略

在创建ThreadPoolExecutor时，可以将拒绝策略作为参数传入：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    maximumPoolSize,
    keepAliveTime,
    timeUnit,
    workQueue,
    handler // 传入拒绝策略
);

代码 Demo

import java.util.concurrent.*;
public class RejectionPolicyExample {
    public static void main(String[] args) {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit timeUnit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        // 使用AbortPolicy作为拒绝策略
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            timeUnit,
            workQueue,
            handler
        );
        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }
        executor.shutdown();
    }
    static class Task implements Runnable {
        private final int taskId;
        Task(int taskId) {
            this.taskId = taskId;
        }
        @Override
        public void run() {
            System.out.println("Executing task " + taskId);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        @Override
        public String toString() {
            return "Task " + taskId;
        }
    }
}

线程池使用AbortPolicy作为拒绝策略。当任务数量超过线程池的处理能力时，将抛出RejectedExecutionException。默认的拒绝策略是AbortPolicy。

88. 线程池的shutDown和shutDownNow的区别⭐⭐

ExecutorService接口中，shutdown()和shutdownNow()是用于关闭线程池的方法。

shutdown()

shutdown()方法会启动线程池的关闭过程。它会停止接受新的任务提交，但会继续执行已经提交的任务(包括正在执行的和已提交但尚未开始执行的任务)。调用shutdown()后，线程池会进入一个平滑的关闭过程，等待所有已提交的任务完成后才会完全终止。

ExecutorServiceexecutorService= Executors.newFixedThreadPool(5);
// 提交一些任务for (inti=0; i < 10; i++) {
    executorService.submit(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
    });
}
// 调用shutdown()
executorService.shutdown();

shutdownNow()

shutdownNow()方法会尝试停止所有正在执行的任务，并返回一个包含尚未开始执行的任务的列表。它会立即停止接收新的任务，并试图中断正在执行的任务。调用shutdownNow()后，线程池会尽快停止所有正在执行的任务，并返回尚未开始执行的任务列表。需要注意的是，无法保证所有正在执行的任务都能被中断。

ExecutorServiceexecutorService= Executors.newFixedThreadPool(5);
// 提交一些任务for (inti=0; i < 10; i++) {
    executorService.submit(() -> {
        System.out.println("Task executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000); // 模拟长时间运行的任务
        } catch (InterruptedException e) {
            System.out.println("Task interrupted");
        }
    });
}
// 调用shutdownNow()
List<Runnable> notExecutedTasks = executorService.shutdownNow();
System.out.println("Tasks not executed: " + notExecutedTasks.size());

89. Java的后台进程是什么？⭐⭐

在Java中，后台进程通常指的是“守护线程”(Daemon Thread)。守护线程是一种特殊类型的线程，它在后台运行，用于执行一些辅助任务。当所有的非守护线程(即用户线程)都结束时，JVM会自动退出，不管守护线程是否还在运行。

守护线程的特点

辅助角色：守护线程通常用于执行一些后台辅助任务，例如垃圾回收、监控等。
自动结束：当所有的非守护线程都结束时，JVM会自动退出，即使还有守护线程在运行。
设置方法：可以通过调用Thread对象的setDaemon(true)方法将线程设置为守护线程。

创建守护线程

创建线程：创建一个普通的线程。
设置为守护线程：在启动线程之前调用setDaemon(true)方法将其设置为守护线程。

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("Daemon thread is running...");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        // 将线程设置为守护线程
        daemonThread.setDaemon(true);
        // 启动守护线程
        daemonThread.start();
        // 主线程睡眠2秒后结束
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Main thread is ending...");
    }
}

在这个例子中：

1、创建了一个Runnable对象，并将其传递给一个新的Thread对象。

2、通过调用daemonThread.setDaemon(true)将线程设置为守护线程。

3、启动守护线程后，主线程睡眠2秒，然后结束。

4、当主线程结束时，JVM会自动退出，即使守护线程还在运行。

注意事项

必须在启动前设置：必须在调用start()方法之前调用setDaemon(true)，否则会抛出IllegalThreadStateException。

守护线程的生命周期：守护线程的生命周期依赖于JVM中其他非守护线程的生命周期。一旦所有非守护线程结束，JVM就会退出，无论守护线程是否还在运行。

不适合重要任务：由于守护线程在JVM退出时不会确保完成其任务，因此不适合用于需要确保完成的关键任务。

90. 多线程的join方法是什么？⭐⭐⭐⭐

join是Thread类中的一个方法，它允许一个线程等待另一个线程的完成。调用join方法的线程将暂停执行，直到被调用join方法的线程完成其执行。使用join方法，可以管理多线程程序的执行流程。

工作原理

当一个线程调用另一个线程的join方法时，当前线程会进入等待状态，直到目标线程完成或指定的等待时间到期。join方法内部是通过wait机制实现的，当目标线程完成时，会调用notifyAll方法唤醒所有等待的线程。

适用场景

线程同步：确保一个线程在另一个线程完成之后再执行。例如，在多线程计算中，主线程需要等待所有子线程完成计算后再汇总结果。

顺序执行：强制线程按特定顺序执行。例如，必须确保某些初始化任务在线程执行之前完成。

代码 Demo

主线程中等待多个子线程完成

publicclassJoinExample{
    publicstaticvoidmain(String[] args) {
        Threadt1=newThread(() -> {
            try {
                Thread.sleep(2000); // 模拟任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread t1 completed");
        });
        Threadt2=newThread(() -> {
            try {
                Thread.sleep(3000); // 模拟任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread t2 completed");
        });
        t1.start();
        t2.start();
        try {
            t1.join(); // 等待t1完成
            t2.join(); // 等待t2完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程将等待t1和t2都完成后，才会继续执行并打印最终的消息
        System.out.println("Main thread completed after t1 and t2");
    }
}

91. 什么是乐观锁？⭐⭐⭐⭐⭐

乐观锁是一种并发控制机制，主要用于解决并发修改问题。与悲观锁不同，乐观锁假设并发冲突的概率较低，因此在操作之前不加锁，而是在操作提交时进行冲突检测。

乐观锁的工作原理

乐观锁通常通过以下两种方式实现：

版本号

1、每条记录增加一个版本号字段。

2、在读取记录时，读取其版本号。

3、在更新记录时，检查当前版本号是否与读取时的版本号一致。

4、如果一致，则更新记录并将版本号加一。

5、如果不一致，则说明有其他事务已经更新了该记录，此时需要重新读取并尝试更新。

时间戳

1、每条记录增加一个时间戳字段。

2、在读取记录时，读取其时间戳。

3、在更新记录时，检查当前时间戳是否与读取时的时间戳一致。

4、如果一致，则更新记录并更新时间戳。

5、如果不一致，则说明有其他事务已经更新了该记录，此时需要重新读取并尝试更新。

适用场景

读多写少：系统中读操作频繁，但写操作较少。例如，电商系统中的商品查询操作。

低冲突：并发冲突概率较低的场景。例如，用户个人信息修改，每个用户只会修改自己的信息。

优缺点

优点

无锁开销：乐观锁不需要在读取时加锁，避免了锁的开销和潜在的死锁问题。

高并发性能：适用于读多写少的场景，能提高系统的并发性能。

缺点

重试机制：当并发冲突发生时，需要重新读取数据并重试更新，可能会增加系统的复杂度。

不适用高冲突场景：在并发冲突频繁的场景下，重试次数可能较多，反而降低系统性能。

92. 乐观锁的ABA 问题⭐⭐⭐⭐⭐

乐观锁的ABA问题是指在并发环境中，一个变量在某个线程检查和更新之间可能会被其他线程多次修改，但最终值看起来没有变化，导致原线程无法检测到这些修改。这种情况会导致数据不一致和潜在的并发问题。

ABA问题的具体场景

假设有一个变量X，其初始值为A。以下是一个可能的ABA问题场景：

线程T1读取变量X，值为A。
线程T1准备更新变量X，但在此之前，线程T2将变量X的值从A改为B，然后又改回A。
线程T1再次检查变量X，发现其值仍然是A，于是认为变量X没有被修改，继续进行更新操作。

在这种情况下，线程T1无法检测到变量X已经被其他线程修改过，导致数据不一致。

解决ABA问题的方法

增加版本号

通过引入版本号，每次更新变量时同时更新版本号。即使变量值恢复原值，版本号也会变化(版本号只会增加不会减少)，从而检测到修改

class VersionedValue {
    int value;
    int version;
    public VersionedValue(int value, int version) {
        this.value = value;
        this.version = version;
    }
}
public boolean compareAndSwap(VersionedValue current, int newValue) {
    synchronized (this) {
        if (current.version == this.version) {
            this.value = newValue;
            this.version++;
            return true;
        }
        return false;
    }
}

使用Java的AtomicStampedReference类

这是Java并发包中的一个类，它不仅存储了对象的引用，还存储了一个“戳”(stamp)，通常是一个版本号或时间戳。每次更新时同时更新戳，从而检测到ABA问题

import java.util.concurrent.atomic.AtomicStampedReference;
public class ABAExample {
    private static AtomicStampedReference<Integer> atomicStampedRef =
        new AtomicStampedReference<>(100, 0);
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int[] stampHolder = new int[1];
            Integer value = atomicStampedRef.get(stampHolder);
            System.out.println("Thread t1 initial value: " + value + ", stamp: " + stampHolder[0]);
            try {
                Thread.sleep(1000); // Simulate some work
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean success = atomicStampedRef.compareAndSet(value, value + 1, stampHolder[0], stampHolder[0] + 1);
            System.out.println("Thread t1 update success: " + success);
        });
        Thread t2 = new Thread(() -> {
            int[] stampHolder = new int[1];
            Integer value = atomicStampedRef.get(stampHolder);
            System.out.println("Thread t2 initial value: " + value + ", stamp: " + stampHolder[0]);
            atomicStampedRef.compareAndSet(value, value + 1, stampHolder[0], stampHolder[0] + 1);
            atomicStampedRef.compareAndSet(value + 1, value, stampHolder[0] + 1, stampHolder[0] + 2);
        });
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int[] stampHolder = new int[1];
        System.out.println("Final value: " + atomicStampedRef.get(stampHolder) + ", final stamp: " + stampHolder[0]);
    }
}

93. 什么是CAS？⭐⭐⭐⭐⭐

CAS(Compare-And-Swap)是一种原子操作，用于实现无锁并发数据结构和算法。它允许一个变量在检查和更新之间不会被其他线程修改，从而确保操作的原子性。

CAS的工作原理

CAS操作涉及三个操作数：

内存位置(V)：需要操作的变量的内存地址。

预期值(E)：期望变量的当前值。

新值(N)：希望将变量更新为的新值。

CAS操作的步骤如下：

读取变量的当前值。
比较变量的当前值与预期值(E)。
如果当前值等于预期值，则将变量更新为新值(N)，并返回true，表示更新成功。
如果当前值不等于预期值，则不进行更新，并返回false，表示更新失败。

boolean compareAndSwap(V, E, N) {
    if (V == E) {
        V = N;
        return true;
    } else {
        return false;
    }
}

CAS的优点

无锁操作：CAS是无锁操作，不需要加锁，从而避免了锁带来的开销和潜在的死锁问题。

高性能：在高并发环境中，CAS操作的性能通常优于加锁机制，因为它减少了线程的阻塞和上下文切换。

原子性：CAS操作是原子的，即使在多线程环境中，也能确保操作的正确性。

CAS的缺点

ABA问题：如前所述，CAS操作可能会遇到ABA问题，即变量在检查和更新之间被其他线程多次修改，但最终值看起来没有变化。可以通过增加版本号或使用AtomicStampedReference来解决。

自旋等待：CAS操作在失败时通常会自旋重试，这可能会导致CPU资源的浪费，尤其是在高冲突场景下。

CAS在Java中的应用

Java提供了一些基于CAS操作的并发类，例如AtomicInteger、AtomicBoolean、AtomicReference等。它们使用CAS操作来实现原子性更新，避免了显式加锁。

import java.util.concurrent.atomic.AtomicInteger;
//AtomicInteger类使用CAS操作来实现原子性递增操作，确保在多线程环境下操作的正确性。
public class CASExample {
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = atomicInteger.get();
            newValue = oldValue + 1;
        } while (!atomicInteger.compareAndSet(oldValue, newValue));
    }
    public int getValue() {
        return atomicInteger.get();
    }
    public static void main(String[] args) {
        CASExample example = new CASExample();
        example.increment();
        System.out.println("Value: " + example.getValue());
    }
}

94. 什么是 AQS(抽象的队列同步器)⭐

AQS(Abstract Queued Synchronizer，抽象的队列同步器)是Java并发包(java.util.concurrent)中的一个框架，用于构建锁和其他同步器(如信号量、读写锁等)。AQS通过一个FIFO(先进先出)的等待队列来管理线程的排队和唤醒，简化了同步器的实现。

AQS的核心概念

状态(state)：AQS通过一个整型变量state来表示同步状态。不同的同步器可以根据自己的需求定义state的含义，例如对于独占锁，state可以表示锁的持有状态；对于共享锁，state可以表示可用资源的数量。

独占模式(Exclusive Mode)：独占模式下，只有一个线程能获取同步状态，其他线程必须等待。例如，ReentrantLock就是基于独占模式实现的。

共享模式(Shared Mode)：共享模式下，多个线程可以同时获取同步状态。例如，Semaphore和CountDownLatch就是基于共享模式实现的。

等待队列(Wait Queue)：AQS内部维护一个FIFO等待队列，用于管理被阻塞的线程。当线程获取同步状态失败时，会被加入到等待队列中，等待其他线程释放同步状态后被唤醒。

AQS的工作原理

AQS通过以下几个核心方法来实现同步器的功能：

acquire(int arg)：以独占模式获取同步状态，如果获取失败，则将当前线程加入等待队列，并阻塞直到同步状态可用。
release(int arg)：以独占模式释放同步状态，唤醒等待队列中的下一个线程(如果有)。
acquireShared(int arg)：以共享模式获取同步状态，如果获取失败，则将当前线程加入等待队列，并阻塞直到同步状态可用。
releaseShared(int arg)：以共享模式释放同步状态，唤醒等待队列中的所有线程(如果有)。
tryAcquire(int arg)：尝试以独占模式获取同步状态，返回true表示获取成功，返回false表示获取失败。需要由具体的同步器实现。
tryRelease(int arg)：尝试以独占模式释放同步状态，返回true表示释放成功，返回false表示释放失败。需要由具体的同步器实现。
tryAcquireShared(int arg)：尝试以共享模式获取同步状态，返回大于等于0的值表示获取成功，返回负值表示获取失败。需要由具体的同步器实现。
tryReleaseShared(int arg)：尝试以共享模式释放同步状态，返回true表示释放成功，返回false表示释放失败。需要由具体的同步器实现。

AQS实现简单独占锁

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
public class SimpleLock {
    private final Sync sync = new Sync();
    private static class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        @Override
        protected boolean tryRelease(int arg) {
            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
    }
    public void lock() {
        sync.acquire(1);
    }
    public void unlock() {
        sync.release(1);
    }
    public boolean isLocked() {
        return sync.isHeldExclusively();
    }
}

tryAcquire(int arg)方法尝试获取锁，通过CAS操作将state从0设置为1。
tryRelease(int arg)方法释放锁，通过将state设置为0并清除当前线程的持有状态。
lock()方法通过调用acquire(1)获取锁。
unlock()方法通过调用release(1)释放锁。
isLocked()方法检查当前锁是否被持有。

95. 创建线程的底层原理⭐⭐

JVM中的线程模型

在JVM中，线程是由操作系统的原生线程(OS Native Thread)实现的。每个Java线程对象都对应一个操作系统级别的线程。JVM通过调用操作系统的线程API来创建和管理这些原生线程。

JVM创建线程的底层原理是通过调用操作系统的原生线程API来实现的。具体步骤包括：

在Java中创建Thread对象并调用start()方法。
JVM通过JNI调用本地方法来创建操作系统级别的线程。
操作系统分配线程控制块(TCB)和栈空间，初始化线程上下文。
操作系统将新线程加入调度队列，线程开始执行run()方法。
线程终止时，JVM清理资源并释放操作系统分配的资源。
Thread.start()调用native的start0()
JVM通过pthread_create()创建一个系统内核线程
在内核线程的运行方法中，利用JavaCalls调用java线程的run()方法

Java线程的创建流程

当在Java中创建和启动一个线程时，JVM会执行以下步骤：

创建Thread对象

首先，用户创建一个Thread对象或实现了Runnable接口的对象。例如：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

调用Thread.start()

调用start()方法时，JVM会启动一个新线程。start()方法的实现会调用JVM的本地方法来创建线程。

JVM调用操作系统API

JNI和本地方法

JVM使用Java本地接口(JNI)来调用操作系统的线程API。Thread.start()方法内部会调用一个本地方法，例如JVM_StartThread。这个本地方法的实现是与平台相关的，它会调用操作系统的线程创建函数。

操作系统线程API

不同操作系统有不同的线程创建API，例如：

POSIX线程(Linux/Unix)：使用pthread_create函数。
Windows线程：使用CreateThread函数。

线程的初始化和启动

分配线程控制块(TCB)

操作系统分配一个线程控制块(TCB)，用于存储线程的状态信息(如寄存器、程序计数器、栈指针等)。

分配栈空间

操作系统为新线程分配独立的栈空间，用于存储局部变量和函数调用信息。

初始化线程上下文

操作系统初始化线程的上下文，包括设置程序计数器(PC)指向线程的起始地址，初始化寄存器和栈指针等。

将线程加入调度队列

操作系统将新线程加入调度队列，以便线程调度器可以调度该线程执行。

线程的执行

操作系统的线程调度器负责将CPU时间分配给各个线程。新创建的线程开始执行时，JVM调用线程对象的run()方法。对于上面的示例，run()方法会输出"Thread is running"。

线程的终止

当线程的run()方法执行完毕或线程被中断时，JVM会清理线程的资源，并通知操作系统释放线程控制块和栈空间。

96. 终止线程的四种方式⭐⭐

正常终止

线程的run()方法执行完毕后，线程会自动终止。这是最自然和安全的终止方式。

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
        // 线程正常执行完毕后终止
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

使用标志位终止

通过设置一个共享的标志位来通知线程终止。这种方式需要线程在合适的地方检查标志位，并自行决定何时终止。

public class MyRunnable implements Runnable {
    private volatile boolean running = true;
    public void run() {
        while (running) {
            System.out.println("Thread is running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
            }
        }
    }
    public void stop() {
        running = false;
    }
    public static void main(String[] args) throws InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        Thread.sleep(5000); // 让线程运行一段时间
        myRunnable.stop(); // 请求线程终止
    }
}

使用interrupt()方法

通过调用线程的interrupt()方法来请求终止线程。线程需要在合适的地方检查是否被中断，并自行决定如何处理。

public class MyRunnable implements Runnable {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
                break; // 跳出循环，终止线程
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        Thread.sleep(5000); // 让线程运行一段时间
        thread.interrupt(); // 请求线程终止
    }
}

用Future的取消方法

如果线程是通过ExecutorService提交的任务，可以使用Future对象的cancel()方法来请求终止线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class MyRunnable implements Runnable {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("Thread is running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
                break; // 跳出循环，终止线程
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<?> future = executor.submit(new MyRunnable());
        Thread.sleep(5000); // 让线程运行一段时间
        future.cancel(true); // 请求线程终止
        executor.shutdown();
    }
}

这四种方式中，正常终止和使用标志位是最推荐的，因为它们最为安全和可控。使用interrupt()方法也是一种常见的方式，但需要注意正确处理InterruptedException。使用Future的取消方法适用于通过ExecutorService提交的任务，但仍然需要任务在合适的地方响应中断请求。强制终止线程(例如使用Thread.stop())是不推荐的，因为它会导致资源泄漏和数据不一致。

97. wait和notifiy的虚假唤醒的产生原因及如何解决⭐⭐⭐⭐

wait()和notify()/notifyAll()方法用于线程间的协调和通信。虚假唤醒是指线程在没有收到实际通知的情况下从wait()状态返回。

虚假唤醒的产生原因

虚假唤醒是操作系统和虚拟机层面上的一种现象，可能由于以下原因产生：

操作系统层面：某些操作系统可能会由于内部调度机制、信号处理或其他原因导致线程被唤醒。
虚拟机实现：Java虚拟机的具体实现可能会在某些情况下发生虚假唤醒。

虽然虚假唤醒在实际中可能不常见，但Java规范明确要求我们在使用wait()方法时必须考虑到这种可能性。

如何解决虚假唤醒

为了处理虚假唤醒，建议在调用wait()方法时使用循环来反复检查条件。具体来说，应该在一个while循环中调用wait()方法，而不是直接在if语句中调用。这确保了即使发生虚假唤醒，线程也会重新检查条件，只有在条件满足时才继续执行。

正确使用wait()和notify()方法来处理虚假唤醒：

class SharedResource {
    private boolean condition = false;
    public synchronized void waitForCondition() {
        while (!condition) { // 使用while循环而不是if语句
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 恢复中断状态
            }
        }
        // 条件满足后继续执行
        System.out.println("Condition met, proceeding...");
    }
    public synchronized void setCondition() {
        condition = true;
        notifyAll(); // 通知所有等待的线程
    }
}
public class SpuriousWakeupExample {
    public static void main(String[] args) throws InterruptedException {
        SharedResource sharedResource = new SharedResource();
        Thread waitingThread = new Thread(sharedResource::waitForCondition);
        waitingThread.start();
        Thread.sleep(2000); // 模拟一些延迟
        Thread notifyingThread = new Thread(sharedResource::setCondition);
        notifyingThread.start();
    }
}

waitForCondition方法：在这个方法中，线程会在条件不满足时进入wait()状态。为了防止虚假唤醒，使用while循环反复检查条件。即使线程被虚假唤醒，它也会重新检查条件，只有在条件满足时才会继续执行。

setCondition方法：这个方法用于设置条件并通知所有等待的线程。通过调用notifyAll()方法，所有在wait()状态的线程都会被唤醒。

99. 引起CPU进行上下文切换的原因⭐

CPU 上下文切换是指 CPU 从一个进程或线程切换到另一个进程或线程的过程。上下文切换涉及保存当前进程或线程的状态，并加载即将运行的进程或线程的状态。上下文切换是多任务操作系统中实现并发的重要机制，但频繁的上下文切换会带来性能开销。

时间片耗尽

在抢占式多任务操作系统中，每个进程或线程都被分配一个固定长度的时间片。当时间片耗尽时，操作系统会进行上下文切换，将 CPU 分配给下一个进程或线程。

阻塞操作

当一个进程或线程执行阻塞操作(如 I/O 操作、等待锁、等待资源等)时，它会进入阻塞状态，操作系统会进行上下文切换，将 CPU 分配给其他可以运行的进程或线程。

进程或线程的优先级变化

操作系统调度程序会根据进程或线程的优先级进行调度。如果一个高优先级的进程或线程进入就绪状态，操作系统可能会进行上下文切换，将 CPU 分配给这个高优先级的进程或线程。

中断

硬件中断(如定时器中断、I/O 中断等)也会触发上下文切换。当中断发生时，操作系统会暂停当前进程或线程的执行，处理中断请求，然后可能会切换到另一个进程或线程。

系统调用

当进程或线程执行系统调用时，可能会引发上下文切换。例如，当进程请求操作系统服务(如文件操作、网络操作等)时，操作系统可能会切换到内核态进行处理，然后再切换回用户态。

多处理器环境中的负载均衡

在多处理器或多核系统中，操作系统可能会进行上下文切换以实现负载均衡。操作系统会将进程或线程分配到不同的 CPU 核心，以优化资源利用率和性能。

线程调度策略

不同的线程调度策略(如时间片轮转、优先级调度等)会导致上下文切换。例如，在时间片轮转调度策略中，每个线程按顺序获得 CPU 时间片，当时间片用完时，操作系统会进行上下文切换。

用户态和内核态切换

当进程或线程从用户态切换到内核态(例如执行系统调用)或从内核态切换回用户态时，也会发生上下文切换。这种切换涉及保存和恢复 CPU 寄存器等状态。

上下文切换的开销

上下文切换虽然是多任务操作系统实现并发的必要机制，但它也带来了性能开销，主要包括：

CPU 寄存器保存和恢复：需要保存当前进程或线程的 CPU 寄存器状态，并加载下一个进程或线程的 CPU 寄存器状态。

内存管理：需要切换内存管理单元(MMU)的上下文，例如页表的切换。

缓存失效：上下文切换可能导致 CPU 缓存失效，从而影响性能。

优化上下文切换

减少线程数量：避免创建过多的线程，合理使用线程池。

减少锁竞争：使用无锁数据结构或更细粒度的锁，减少线程间的锁竞争。

优化调度策略：根据应用场景选择合适的调度策略，避免不必要的优先级切换。

使用异步 I/O：尽量使用异步 I/O 操作，减少阻塞操作引起的上下文切换。

100. 线程什么时候主动放弃CPU⭐

线程主动放弃 CPU常见的有以下几种方式

调用Thread.yield()方法
调用Thread.sleep(long millis)方法
调用Object.wait()方法
调用Thread.join()方法
调用LockSupport.park()方法

Thread.yield()

Thread.yield()是一个静态方法，通知调度器当前线程愿意放弃 CPU 使用权，让其他同优先级或更高优先级的线程有机会运行。它只是一个提示，操作系统可以选择忽略这个提示。

场景

调试和性能优化：在某些情况下，yield()可以用于调试和性能优化，帮助识别线程调度问题。

避免资源独占：在某些高优先级的任务中，使用yield()可以避免线程长时间独占 CPU，稍微改善系统响应时间。

public class YieldExample {
    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " is yielding");
                Thread.yield();
            }
        };
        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");
        t1.start();
        t2.start();
    }
}

Thread.sleep(long millis)

Thread.sleep(long millis)使当前线程进入休眠状态，暂停执行指定的毫秒数。休眠期间，线程保持 CPU 使用权，但不执行任何代码。

场景

定时任务：在需要定时执行任务的场景中，sleep()可以用于实现简单的定时等待。

模拟延迟：在测试和模拟场景中，sleep()可以用于模拟网络延迟或其他等待时间。

public class SleepExample {
    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                System.out.println(Thread.currentThread().getName() + " is sleeping");
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " woke up");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };
        Thread t1 = new Thread(task, "Thread-1");
        t1.start();
    }
}

Object.wait()

Object.wait()使当前线程等待，直到其他线程调用notify()或notifyAll()方法唤醒它。wait()必须在同步块或同步方法中调用。

场景

线程间通信：在生产者-消费者模型中，wait()和notify()用于协调生产者和消费者线程之间的工作。

public class WaitNotifyExample {
    private static final Object lock = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println(Thread.currentThread().getName() + " is waiting");
                    lock.wait();
                    System.out.println(Thread.currentThread().getName() + " is resumed");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "Thread-1");
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + " is notifying");
                lock.notify();
            }
        }, "Thread-2");
        t1.start();
        try {
            Thread.sleep(1000); // 确保 t1 先执行
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        t2.start();
    }
}

Thread.join()

Thread.join()使当前线程等待，直到另一个线程执行完毕。可以指定等待时间，也可以无限期等待。

场景

线程协调：在需要确保某些线程在其他线程之前完成时，使用join()来协调线程的执行顺序。

public class JoinExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + " is working");
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " finished");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Thread-1");
        t1.start();
        try {
            t1.join();
            System.out.println("Main thread resumed after Thread-1 finished");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

LockSupport.park()

LockSupport.park()使当前线程阻塞，直到被其他线程通过LockSupport.unpark(Thread)唤醒。park()不会释放线程持有的锁，但可以响应中断。

场景

线程控制：在需要精细控制线程行为的场景中，park()和unpark()提供了更底层和灵活的线程控制机制。

import java.util.concurrent.locks.LockSupport;
public class LockSupportExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " is going to park.");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + " has been unparked.");
        }, "Thread-1");
        t1.start();
        try {
            Thread.sleep(3000); // 让线程运行3秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Unparking Thread-1.");
        LockSupport.unpark(t1); // 唤醒线程
    }
}

总结

Thread.yield()：提示调度器当前线程愿意放弃 CPU 使用权，适用于调试和性能优化。

Thread.sleep(long millis)：使线程休眠指定时间，适用于定时任务和模拟延迟。

Object.wait()：使线程等待，直到被notify()或notifyAll()唤醒，适用于线程间通信。

Thread.join()：使当前线程等待另一个线程执行完毕，适用于线程协调。

LockSupport.park()：使线程阻塞，直到被unpark()唤醒，适用于高级线程控制。

101. 为什么说线程的上下文切换效率不高⭐

线程的上下文切换效率不高主要是因为它涉及多个复杂的操作，这些操作会消耗 CPU 时间和系统资源。

CPU 寄存器状态保存和恢复

当进行上下文切换时，操作系统需要保存当前线程的 CPU 寄存器状态，包括程序计数器、堆栈指针、通用寄存器等。然后，它需要加载即将运行的线程的寄存器状态。这一过程需要时间，并且在频繁上下文切换时，会带来显著的开销。

内存管理开销

线程上下文切换可能涉及内存管理单元(MMU)的切换，比如页表的切换。虽然线程通常共享同一个进程的地址空间，但在某些情况下(如不同的线程池或不同的任务)，仍然可能需要进行复杂的内存管理操作。

缓存失效

上下文切换会导致 CPU 缓存失效。当一个线程被切换出去，另一个线程被切换进来时，新线程访问的数据可能不在缓存中，导致缓存命中率下降。这会增加内存访问延迟，从而影响性能。

调度器开销

线程调度器需要决定哪个线程应该运行，这涉及到复杂的算法和数据结构操作。调度器需要遍历就绪队列、计算优先级、处理时间片等，这些操作都会消耗 CPU 时间。

内核态和用户态切换

线程上下文切换通常涉及从用户态切换到内核态，再从内核态切换回用户态。这种切换本身就有开销，因为需要保存和恢复更多的状态信息，并且可能涉及安全检查和权限验证。

频繁的上下文切换

如果系统中线程数量过多或线程频繁阻塞和唤醒，导致频繁的上下文切换，这种情况会显著影响系统的整体性能。频繁的上下文切换会导致 CPU 大量时间花费在保存和恢复状态上，而不是实际执行任务。

102. 线程的安全三大特性⭐

线程安全确保多个线程能够正确、无冲突地访问共享资源。线程安全的三大核心特性是原子性、可见性和有序性。

原子性 (Atomicity)

原子性指的是一个操作或一系列操作要么全部执行，要么全部不执行，中间不会被其他线程干扰。原子操作是不可分割的，任何线程都不能中断它们。

原子操作：如读取和写入单个变量。

非原子操作：如自增操作i++(它实际上包括读取、更新和写入三个步骤)。

解决方案：

使用同步块或锁(如ReentrantLock)来确保操作的原子性。

使用原子类(如AtomicInteger、AtomicLong等)来处理基本类型的原子操作。

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet(); // 原子性自增操作
    }
}

可见性 (Visibility)

可见性指的是一个线程对共享变量的修改，能够及时被其他线程看到。多线程环境下，线程对共享变量的修改可能不会立即被其他线程感知，因为每个线程都有自己的缓存(如CPU缓存)。一个线程修改了一个变量，但另一个线程读取到的仍然是旧值。

解决方案：

使用volatile关键字：确保变量的修改对所有线程立即可见。
使用同步块或锁：同步块不仅可以保证原子性，还可以保证可见性。
线程间通信机制：如wait()和notify()。

public class VisibilityExample {
    private volatile boolean flag = false;
    public void writer() {
        flag = true; // 修改对其他线程立即可见
    }
    public void reader() {
        if (flag) {
            // 读取到最新的flag值
        }
    }
}

有序性 (Ordering)

有序性指的是程序执行的顺序按照代码的顺序来执行。在多线程环境下，由于编译器优化和CPU指令重排，代码的执行顺序可能与编写顺序不同。指令重排可能导致线程看到不一致的执行顺序。

解决方案：

使用volatile关键字：不仅保证可见性，还禁止指令重排。
使用同步块或锁：同步块不仅可以保证原子性和可见性，还可以保证进入和退出同步块的代码顺序。
内存屏障(Memory Barriers)：低级别的控制指令重排的技术。

public class OrderingExample {
    private int a = 0;
    private boolean flag = false;
    public void writer() {
        a = 1; // 1
        flag = true; // 2
    }
    public void reader() {
        if (flag) { // 3
            int i = a; // 4
            // 这里i可能是0，因为1和2可能被重排
        }
    }
}

总结

原子性：确保操作不可分割，使用同步块、锁或原子类。

可见性：确保线程间的修改及时可见，使用volatile关键字、同步块或锁。

有序性：确保代码执行顺序符合预期，使用volatile关键字、同步块或内存屏障。

103. 介绍一下volatile⭐⭐⭐⭐⭐

线程安全确保多个线程能够正确、无冲突地访问共享资源。线程安全的三大核心特性是原子性、可见性和有序性。

原子性 (Atomicity)

原子性指的是一个操作或一系列操作要么全部执行，要么全部不执行，中间不会被其他线程干扰。原子操作是不可分割的，任何线程都不能中断它们。

原子操作：如读取和写入单个变量。

非原子操作：如自增操作i++(它实际上包括读取、更新和写入三个步骤)。

解决方案：

使用同步块或锁(如ReentrantLock)来确保操作的原子性。

使用原子类(如AtomicInteger、AtomicLong等)来处理基本类型的原子操作。

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet(); // 原子性自增操作
    }
}

可见性 (Visibility)

解决方案：

使用volatile关键字：确保变量的修改对所有线程立即可见。
使用同步块或锁：同步块不仅可以保证原子性，还可以保证可见性。
线程间通信机制：如wait()和notify()。

public class VisibilityExample {
    private volatile boolean flag = false;
    public void writer() {
        flag = true; // 修改对其他线程立即可见
    }
    public void reader() {
        if (flag) {
            // 读取到最新的flag值
        }
    }
}

有序性 (Ordering)

解决方案：

使用volatile关键字：不仅保证可见性，还禁止指令重排。
使用同步块或锁：同步块不仅可以保证原子性和可见性，还可以保证进入和退出同步块的代码顺序。
内存屏障(Memory Barriers)：低级别的控制指令重排的技术。

public class OrderingExample {
    private int a = 0;
    private boolean flag = false;
    public void writer() {
        a = 1; // 1
        flag = true; // 2
    }
    public void reader() {
        if (flag) { // 3
            int i = a; // 4
            // 这里i可能是0，因为1和2可能被重排
        }
    }
}

总结

原子性：确保操作不可分割，使用同步块、锁或原子类。

可见性：确保线程间的修改及时可见，使用volatile关键字、同步块或锁。

有序性：确保代码执行顺序符合预期，使用volatile关键字、同步块或内存屏障。

104. 什么是指令重排⭐

指令重排是编译器优化中的一种技术，旨在提高程序执行效率。它允许编译器和处理器在不改变程序最终结果的前提下，重新排列指令的执行顺序。指令重排可以利用处理器的并行执行能力和优化内存访问，以提高程序的性能。

为什么需要指令重排？

提高指令级并行性：现代处理器具有多条流水线，可以同时执行多条指令。通过重排指令，可以更好地利用这些流水线，提高指令级并行性。

减少等待时间：某些指令可能会因为数据依赖或内存访问延迟而等待。通过重排指令，可以将这些等待时间隐藏在其他指令的执行过程中，从而提高整体执行效率。

指令重排的类型

编译器重排：编译器在生成目标代码时，重新排列指令的顺序，以优化性能。这种重排通常基于数据流分析和依赖关系分析。
处理器重排：现代处理器在运行时动态地重新排列指令，以提高执行效率。这种重排利用了处理器的乱序执行(Out-of-Order Execution)能力。

指令重排 Demo

假设有以下两条指令：

Plain Text int a = 1; // 指令1 int b = 2; // 指令2

在没有数据依赖的情况下，编译器或处理器可以将这两条指令的顺序互换，而不会影响程序的最终结果：

Plain Text int b = 2; // 指令2 int a = 1; // 指令1

指令重排对多线程编程的影响

在多线程环境中，指令重排可能会导致意想不到的结果，尤其是在没有适当的同步机制时。考虑以下示例：

Plain Text // 线程1 x = 1; // 指令1 y = 2; // 指令2 // 线程2 if (y == 2) { // 期望x == 1 }

在单线程环境中，我们可以合理地认为，如果y的值是2，那么x的值应该是1。然而，由于指令重排，可能会出现以下情况：

Plain Text // 线程1 y = 2; // 指令2 x = 1; // 指令1 // 线程2 if (y == 2) { // 可能x != 1 }

在这种情况下，线程2可能会在y被设置为2之后，但在x被设置为1之前执行，从而导致不一致的状态。

如何防止指令重排

为了防止指令重排导致的多线程问题，可以使用以下方法：

volatile关键字：在Java中，使用volatile关键字可以禁止特定类型的指令重排。声明为volatile的变量在被写入时会立即被刷新到主内存，在被读取时会从主内存中读取，确保变量的可见性和有序性。

Plain Text private volatile int x = 0;

同步机制：使用同步块(synchronized)或显式锁(如ReentrantLock)可以确保在同步块内的指令按预期顺序执行，防止指令重排。

Plain Text private int x = 0; 
public synchronized void setX(int value) {  
	x = value; 
} 
public synchronized int getX() {   
	return x; 
}

内存屏障：在底层，内存屏障(Memory Barrier)或内存栅栏(Memory Fence)是一种指令，用于防止特定类型的指令重排。如Java的Unsafe类提供了对内存屏障的支持。

105. 为什么指令重排能够提高性能？⭐

指令重排是指编译器或处理器在不改变程序语义的前提下，重新安排指令的执行顺序，以提高程序执行效率的一种优化技术。

为什么指令重排能够提高性能

利用处理器的乱序执行能力

现代处理器通常具有乱序执行能力，这意味着处理器可以根据指令的依赖关系和资源可用性，动态地调整指令的执行顺序。这样做的主要目的是最大化处理器资源的利用率，减少等待时间。

假设有以下指令序列：

int a = loadFromMemory(address1); // 指令1
int b = a + 5;                    // 指令2
int c = loadFromMemory(address2); // 指令3
int d = c * 2;                    // 指令4

指令1和指令2存在数据依赖关系，而指令3和指令4则与前两条指令无关。处理器可以重排指令，使得指令3在指令1之后立即执行，而不必等待指令2的执行结果：

int a = loadFromMemory(address1); // 指令1
int c = loadFromMemory(address2); // 指令3
int b = a + 5;                    // 指令2
int d = c * 2;                    // 指令4

这样，处理器可以在等待指令1的内存读取时，先执行指令3，从而减少整体等待时间，提高执行效率。

减少数据依赖导致的等待时间

指令重排可以减少由于数据依赖(Data Dependency)导致的等待时间。数据依赖指的是一条指令需要等待前一条指令的结果才能执行。

假设有以下指令序列：

int a = loadFromMemory(address1); // 指令1
int b = a + 5;                    // 指令2
int c = loadFromMemory(address2); // 指令3
int d = c * 2;                    // 指令4

指令2依赖于指令1的结果，但指令3和指令4与前两条指令无关。处理器可以重排指令，使得指令3和指令4在指令2之前执行，从而减少等待时间：

int a = loadFromMemory(address1); // 指令1
int c = loadFromMemory(address2); // 指令3
int d = c * 2;                    // 指令4
int b = a + 5;                    // 指令2

这样，指令3和指令4可以在等待指令1的内存读取时执行，从而减少整体等待时间，提高执行效率。

提高指令级并行性

指令重排可以提高指令级并行性(Instruction-Level Parallelism, ILP)，即在同一时刻可以并行执行的指令数量。通过重排指令，可以更好地填充处理器的流水线(Pipeline)，减少流水线停顿(Pipeline Stalls)。

假设处理器有两个执行单元，可以同时执行两条指令。原始指令序列：

int a = loadFromMemory(address1); // 指令1
int b = a + 5;                    // 指令2
int c = loadFromMemory(address2); // 指令3
int d = c * 2;                    // 指令4

如果处理器重排指令，将指令3提前：

int a = loadFromMemory(address1); // 指令1
int c = loadFromMemory(address2); // 指令3
int b = a + 5;                    // 指令2
int d = c * 2;                    // 指令4

这样，指令1和指令3可以同时执行，提高了指令级并行性。

隐藏内存访问延迟

内存访问通常比处理器执行指令要慢得多。指令重排可以将内存访问的延迟隐藏在其他指令的执行过程中，从而提高整体性能。

假设有以下指令序列：

int a = loadFromMemory(address1); // 指令1
int b = a + 5;                    // 指令2
int c = loadFromMemory(address2); // 指令3
int d = c * 2;                    // 指令4

处理器可以重排指令，将两个加载指令分开，以隐藏内存访问延迟：

int a = loadFromMemory(address1); // 指令1
int c = loadFromMemory(address2); // 指令3
int b = a + 5;                    // 指令2
int d = c * 2;                    // 指令4

这样，在等待加载数据的同时，处理器可以执行其他指令，提高了整体效率。

106. volatile如何防止了指令重排⭐⭐

在Java中，volatile关键字用于修饰变量，以确保对该变量的读写操作具有可见性和有序性。具体来说，volatile变量的读写操作会有以下两个主要特性：

可见性：当一个线程修改了volatile变量的值，新的值对于其他所有线程立即可见。
有序性：volatile关键字可以防止指令重排，从而保证代码执行的顺序性。

防止指令重排

volatile关键字防止指令重排的机制主要依赖于内存屏障(Memory Barriers，也称为内存栅栏)。内存屏障是一种指令，用于限制处理器和编译器对指令的重排序行为。

内存屏障的作用

内存屏障分为四种类型：

LoadLoad Barrier：确保在此屏障之前的所有读操作在屏障之后的读操作之前完成。

StoreStore Barrier：确保在此屏障之前的所有写操作在屏障之后的写操作之前完成。

LoadStore Barrier：确保在此屏障之前的所有读操作在屏障之后的写操作之前完成。

StoreLoad Barrier：确保在此屏障之前的所有写操作在屏障之后的读操作之前完成。

在Java中，volatile变量的读写操作会插入特定的内存屏障，以确保有序性：

读屏障

在每个volatile读操作的后面插入一个loadload屏障，禁止处理器把上面的volatile读与下面的普通读重排序。

在每个volatile读操作的后面插入一个loadstore屏障，禁止处理器把上面的volatile读与下面的普通写重排序。

写屏障

在每个volatile写操作的前面插入一个storestore屏障，可以保证在volatile写之前，其前面的所有普通写操作都已经刷新到主内存中。

在每个volatile写操作的后面插入一个storeload屏障，作用是避免volatile写与后面可能有的volatile读/写操作重排)

107. volatile保证线程的可见性和有序性，不保证原子性是为什么？⭐

保证线程的可见性

可见性原理

在多线程环境中，每个线程都有自己的工作内存(缓存)，从主存中读取变量复制到工作内存中进行操作，操作完成后再写回主存。普通变量的修改在一个线程中进行后，其他线程并不一定能立即看到，因为这个修改可能只存在于工作内存中，尚未刷新到主存。

volatile关键字通过一套内存屏障(Memory Barrier)机制来保证变量的可见性。具体来说，当一个变量被声明为volatile时：

写操作：在写入volatile变量时，会在写操作之后插入一个写屏障(Store Barrier)。这确保了在写入volatile变量之前，对共享变量的修改会被同步到主存中。

读操作：在读取volatile变量时，会在读操作之前插入一个读屏障(Load Barrier)。这确保了在读取volatile变量之后，能从主存中获取最新的值。

public class VolatileExample {
    private volatile boolean flag = false;
    public void setFlag() {
        flag = true;
    }
    public void checkFlag() {
        while (!flag) {
            // Busy-wait
        }
        System.out.println("Flag is set!");
    }
}

在这个例子中，当一个线程调用setFlag()方法时，flag被设置为true，并且这个修改会立即被刷新到主存中。其他线程在调用checkFlag()方法时，会从主存中读取flag的最新值，从而跳出循环。

保证有序性

有序性原理

在 Java 内存模型中，编译器和处理器为了优化性能，可能会对指令进行重排序。重排序不会影响单线程程序的正确性，但在多线程环境下可能会导致不可预期的问题。

volatile关键字通过内存屏障来防止指令重排，从而保证有序性。

写操作：在写入volatile变量时，会在写操作之前插入一个写屏障。这确保了在写入volatile变量之前的所有写操作都不会被重排序到写屏障之后。

读操作：在读取volatile变量时，会在读操作之后插入一个读屏障。这确保了在读取volatile变量之后的所有读操作都不会被重排序到读屏障之前。

public class VolatileOrderingExample {
    private volatile int a = 0;
    private int b = 0;
    public void writer() {
        a = 1; // Write to volatile variable
        b = 2; // Write to non-volatile variable
    }
    public void reader() {
        if (a == 1) {
            // If this condition is true, it guarantees that b == 2 due to the happens-before relationship
            System.out.println("b = " + b);
        }
    }
}

由于a是volatile变量，写入a之前的所有写操作(包括写入b)在写入a之后对其他线程都是可见的。因此，如果a == 1，那么b必然已经被写入2。

为什么不保证原子性

原子性原理

原子性指的是一个操作是不可分割的，即操作要么全部执行完毕，要么完全不执行。volatile保证了对变量的单次读/写操作是原子的，但无法保证复合操作(如自增、自减)的原子性。

public class VolatileAtomicityExample {
    private volatile int count = 0;
    public void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

在这个例子中，count++实际上包含了三个步骤：

读取count的值
将count的值加 1
将新值写回count

这些步骤并不是一个原子操作，可能会被其他线程打断。例如，两个线程同时执行increment()方法时，可能会发生竞态条件，导致count的值不如预期。例如：

线程 A 读取count的值为 0
线程 B 读取count的值为 0
线程 A 将count的值加 1 并写回(count变为 1)
线程 B 将count的值加 1 并写回(count变为 1)

最终count的值是 1 而不是 2。

108. 什么是内存屏障？⭐

内存屏障也称为内存栅栏，是一种用于控制处理器和编译器对内存操作进行重排序的指令。内存屏障确保在特定点之前的内存操作完成后，才会进行该点之后的内存操作。因为它们可以确保内存操作的可见性和有序性，从而避免数据竞争和其他并发问题。

内存屏障的类型

内存屏障主要有以下几种类型，每种类型的屏障对内存操作的重排序有不同的限制：

LoadLoad Barrier：

确保在此屏障之前的所有读操作在屏障之后的读操作之前完成。

示例：Load1; LoadLoad; Load2保证Load1在Load2之前完成。

StoreStore Barrier：

确保在此屏障之前的所有写操作在屏障之后的写操作之前完成。

示例：Store1; StoreStore; Store2保证Store1在Store2之前完成。

LoadStore Barrier：

确保在此屏障之前的所有读操作在屏障之后的写操作之前完成。

示例：Load1; LoadStore; Store2保证Load1在Store2之前完成。

StoreLoad Barrier：

确保在此屏障之前的所有写操作在屏障之后的读操作之前完成。StoreLoad屏障通常是最昂贵的，因为它会导致处理器流水线的刷新。

示例：Store1; StoreLoad; Load2保证Store1在Load2之前完成。

内存屏障的作用

内存屏障在多线程编程中有以下几个主要作用：

防止指令重排：

编译器和处理器可能会对指令进行重排，以优化性能。然而，在多线程环境下，这种重排可能会导致数据不一致。内存屏障通过限制重排，确保特定顺序的内存操作。

确保内存可见性：

内存屏障确保一个线程对内存的修改对其他线程立即可见。这对于实现正确的同步原语(如锁、信号量)至关重要。

内存屏障在Java中的实现

在Java中，volatile关键字通过内存屏障来实现其可见性和有序性保证。具体来说，volatile变量的读写操作会插入相应的内存屏障。

假设有以下代码：

volatile boolean flag = false;
int a = 0;
// Thread 1
a = 1; // 普通写操作
flag = true; // volatile 写操作
// Thread 2
if (flag) { // volatile 读操作
    System.out.println(a); // 普通读操作
}

在这段代码中：

Thread 1：

a = 1是普通写操作。

flag = true是volatile写操作。在这之后插入了StoreStore Barrier和StoreLoad Barrier。

这确保了a = 1在flag = true之前完成，并且flag = true之后的任何读操作不会被重排到flag = true之前。

Thread 2：

if (flag)是volatile读操作。在这之前插入了LoadLoad Barrier和LoadStore Barrier。

这确保了if (flag)之前的任何读操作不会被重排到if (flag)之后，并且if (flag)之后的任何写操作不会被重排到if (flag)之前。

109. happen-before原则⭐

Happens-before原则是Java内存模型中的一个核心概念，用于定义多线程程序中操作的执行顺序和内存可见性。通过happens-before关系，我们可以推断出线程之间的内存操作如何相互影响，从而确保线程安全。

Happens-before原则的定义

如果一个操作A happens-before另一个操作B，那么在多线程环境中，A的结果对B是可见的，并且A在时间上先于B执行。具体来说，happens-before关系确保了两个操作之间的可见性和顺序性。

Happens-before规则

Java内存模型定义了一些基本的happens-before规则，这些规则描述了不同操作之间的顺序关系：

程序次序规则(Program Order Rule)：在一个线程中，按照程序顺序，前面的操作happens-before后面的操作。
监视器锁规则(Monitor Lock Rule)：对一个锁的解锁(unlock)操作happens-before对同一个锁的加锁(lock)操作。
传递性(Transitivity)：如果操作A happens-before操作B，且操作B happens-before操作C，那么操作A happens-before操作C。
线程启动规则(Thread Start Rule)：在一个线程中，对另一个线程的Thread.start()调用happens-before该线程中的任何操作。
线程终止规则(Thread Termination Rule)：一个线程中的所有操作happens-before另一个线程调用该线程的Thread.join()并成功返回。
中断规则(Interrupt Rule)：对线程的Thread.interrupt()调用happens-before被中断线程检测到中断事件的发生(通过Thread.isInterrupted()或抛出InterruptedException)。
对象构造规则(Object Construction Rule)：一个对象的构造函数的结束happens-before该对象的finalize()方法的开始。

Happens-before原则的应用

程序次序规则

Plain Text int a = 1; // 操作A int b = 2; // 操作B

在同一个线程中，操作A happens-before操作B，确保了操作A的结果对操作B可见。

监视器锁规则

Plain Text synchronized(lock) { // 操作A } synchronized(lock) { // 操作B }

对lock的解锁操作(操作A)happens-before对同一个lock的加锁操作(操作B)。

线程启动规则

Plain Text Thread t = new Thread(() -> { // 操作B }); t.start(); // 操作A

在主线程中，对Thread t的start()调用(操作A)happens-before新线程中的任何操作(操作B)。

Happens-before原则的意义

Happens-before原则为开发者提供了一套明确的规则，用于推断多线程程序中操作的执行顺序和内存可见性。这有助于编写正确和高效的并发程序，避免数据竞争和其他并发问题。通过遵循这些规则，开发者可以确保线程间的正确同步，确保程序的正确性和稳定性。

110. synchronized的底层实现？⭐⭐⭐⭐⭐

synchronized关键字在Java中用于实现线程同步，确保同一时间只有一个线程可以执行同步代码块或方法。它的底层实现依赖于JVM和操作系统提供的锁机制。

Monitor(监视器)机制

synchronized的底层实现依赖于一个称为“监视器”(Monitor)的机制。每个对象在Java中都有一个与之关联的监视器锁(Monitor Lock)。当一个线程进入一个synchronized方法或代码块时，它会尝试获取该对象的监视器锁。

JVM指令

synchronized关键字会被编译器转换为字节码中的两条指令：monitorenter和monitorexit。

monitorenter：当线程进入同步方法或代码块时，尝试获取对象的监视器锁。如果锁已经被其他线程持有，当前线程会被阻塞，直到锁被释放。

monitorexit：当线程退出同步方法或代码块时，释放对象的监视器锁。

对象头(Object Header)

在HotSpot JVM中，对象头(Object Header)包含了锁信息。对象头中有一个Mark Word(标记字段)，用于存储锁状态和其他信息。锁可以有多种状态，主要包括以下几种：

无锁(Unlocked)：对象没有被任何线程持有锁。

偏向锁(Biased Locking)：一个线程偏向于持有锁，减少了加锁和解锁的开销。

轻量级锁(Lightweight Locking)：通过CAS(Compare-And-Swap)操作实现的锁，适用于低竞争的场景。

重量级锁(Heavyweight Locking)：通过操作系统的互斥量(Mutex)实现的锁，适用于高竞争的场景。

锁的升级

JVM会根据竞争情况在不同的锁状态之间进行升级

偏向锁：默认情况下，JVM会尝试使用偏向锁，当一个线程多次进入同步块时，不需要每次都进行加锁操作。

轻量级锁：如果有多个线程竞争同一个锁，偏向锁会升级为轻量级锁。

重量级锁：如果锁竞争激烈，轻量级锁会升级为重量级锁。

锁消除和锁粗化

JVM在运行时会进行一些优化来减少锁的开销：

锁消除(Lock Elimination)：JVM在JIT编译时会分析代码，如果发现某些锁是多余的(如局部变量锁)，会自动消除这些锁。

锁粗化(Lock Coarsening)：JVM会将多个连续的加锁和解锁操作合并为一个更大的加锁操作，减少锁的开销。

111. synchronized和lock的区别⭐⭐⭐⭐⭐

synchronized和Lock是Java中用于实现线程同步的两种机制。它们都能确保线程安全。

synchronized关键字

synchronized是Java语言内置的同步机制，用于在方法或代码块上实现互斥锁。

public class SynchronizedExample {
    private int count = 0;
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    // 同步代码块
    public void incrementWithBlock() {
        synchronized (this) {
            count++;
        }
    }
}

用法简单：可以直接在方法声明上使用，表示整个方法是同步的。可以在代码块上使用，指定某个对象作为锁。
隐式锁：synchronized使用的是隐式锁(内置锁或监视器锁)，每个对象都有一个隐式锁。
自动释放锁：当线程退出synchronized方法或代码块时，锁会自动释放，无需手动释放。
不可中断：如果一个线程在等待获取锁时被阻塞，无法中断该线程。
性能开销：早期版本的Java中，synchronized的性能较低，但从Java 6开始，JVM对synchronized进行了大量优化，使其性能显著提升。

Lock接口(及其实现)

Lock是Java 5引入的更灵活的同步机制，位于java.util.concurrent.locks包中。Lock接口提供了更丰富的锁功能，主要特点和使用方式如下：

灵活性更高：Lock接口提供了多种实现，如ReentrantLock，可以实现更加复杂的同步需求。提供了可中断锁、超时获取锁、非阻塞尝试获取锁等功能。
显式锁：需要显式地获取和释放锁，使用lock()方法获取锁，使用unlock()方法释放锁。
可中断锁：可以通过lockInterruptibly()方法获取锁，允许在等待锁时响应中断。
条件变量：Lock接口提供了条件变量(Condition)，可以实现更加复杂的等待/通知机制。
性能开销：在某些情况下，Lock的性能可能优于synchronized，特别是在高竞争的情况下。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockExample {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    public void incrementWithInterrupt() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

选择建议

对于简单的同步需求，synchronized通常已经足够，并且其代码更加简洁和易读。

对于需要更高灵活性、可中断锁、超时获取锁或条件变量的复杂同步需求，Lock接口及其实现(如ReentrantLock)是更好的选择。

选择哪种同步机制取决于具体的需求和场景。在大多数情况下，synchronized已经能够满足需求，但在一些特殊场景下，Lock提供了更强大的功能和更高的灵活性。

112. 线程池的异步任务执行完后，如何回调⭐

使用Future和Callable

Future接口提供了一种检查任务是否完成、获取任务结果的方法。可以通过轮询Future.isDone()方法来检查任务是否完成，或者直接调用Future.get()方法来获取结果(此方法会阻塞直到任务完成)。

ExecutorService executor = Executors.newFixedThreadPool(10);
Callable<String> task = () -> {
    // 执行任务
    return "Task Result";
};
Future<String> future = executor.submit(task);
// 轮询检查任务是否完成
while (!future.isDone()) {
    // 可以做其他事情
}
// 获取任务结果
try {
    String result = future.get();
    // 任务完成后的回调处理
    System.out.println("Task completed with result: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

使用CompletionService

CompletionService提供了一种更方便的方式来处理异步任务的结果。它可以将任务提交到线程池，并在任务完成后立即处理结果。

ExecutorService executor = Executors.newFixedThreadPool(10);
CompletionService<String> completionService = new ExecutorCompletionService<>(executor);
Callable<String> task = () -> {
    // 执行任务
    return "Task Result";
};
completionService.submit(task);
// 获取并处理任务结果
try {
    Future<String> future = completionService.take(); // 阻塞直到有任务完成
    String result = future.get();
    // 任务完成后的回调处理
    System.out.println("Task completed with result: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

使用CompletableFuture

CompletableFuture是 Java 8 引入的一个类，提供了更强大的异步编程能力。它允许在任务完成后执行回调操作。

CompletableFuture.supplyAsync(() -> {
    // 执行任务
    return "Task Result";
}).thenAccept(result -> {
    // 任务完成后的回调处理
    System.out.println("Task completed with result: " + result);
});

使用自定义回调接口

可以定义一个回调接口，并在任务完成后调用回调方法。

// 定义回调接口
interface Callback {
    void onComplete(String result);
}
// 实现回调接口
class MyCallback implements Callback {
    @Override
    public void onComplete(String result) {
        System.out.println("Task completed with result: " + result);
    }
}
// 提交任务并在完成后回调
ExecutorService executor = Executors.newFixedThreadPool(10);
Callback callback = new MyCallback();
executor.submit(() -> {
    String result = "Task Result"; // 执行任务
    callback.onComplete(result); // 调用回调
});

使用FutureTask

FutureTask是一个同时实现了Runnable和Future的类，可以在任务完成后执行回调操作。

ExecutorService executor = Executors.newFixedThreadPool(10);
FutureTask<String> futureTask = new FutureTask<>(() -> {
    // 执行任务
    return "Task Result";
}) {
    @Override
    protected void done() {
        try {
            String result = get();
            // 任务完成后的回调处理
            System.out.println("Task completed with result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
};
executor.submit(futureTask);

113. synchronized能否被打断，什么情况下打断⭐⭐⭐⭐

synchronized关键字在 Java 中用于实现同步控制，确保同一时间只有一个线程可以访问被同步的方法或代码块。synchronized块或方法本质上是不可被打断的，即一旦一个线程获得了对象的监视器锁(monitor lock)，其他线程就无法中断它，而只能等待这个锁被释放。持有synchronized锁的线程不可被打断。等待获取synchronized锁的线程可以被打断，但不会抛出InterruptedException，而是继续等待锁的释放。

不可被打断：当一个线程进入一个synchronized方法或代码块并获得了锁时，其他试图进入该synchronized方法或代码块的线程将被阻塞，直到持有锁的线程退出该synchronized方法或代码块并释放锁。此时，等待的线程会依次尝试获得锁。
等待锁时可以被打断：虽然持有锁的线程不可被打断，但等待获取锁的线程是可以被打断的。具体来说，当一个线程在等待进入一个被synchronized修饰的方法或代码块时，如果该线程被其他线程调用了Thread.interrupt()方法，那么该线程会被设置为中断状态，但不会抛出InterruptedException。也就是说，线程仍然会继续等待获取锁，直到锁被释放。

demo

public class SynchronizedInterruptExample {
    private final Object lock = new Object();
    public void synchronizedMethod() {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName() + " has acquired the lock.");
                Thread.sleep(5000); // 模拟长时间运行的任务
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " was interrupted.");
            }
        }
    }
    public static void main(String[] args) {
        SynchronizedInterruptExample example = new SynchronizedInterruptExample();
        Thread t1 = new Thread(example::synchronizedMethod, "Thread-1");
        Thread t2 = new Thread(example::synchronizedMethod, "Thread-2");
        t1.start();
        t2.start();
        try {
            Thread.sleep(1000); // 确保 t1 已经获得锁
            t2.interrupt(); // 尝试中断 t2
            System.out.println("Thread-2 interrupt signal sent.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中：

Thread-1首先获得了锁并执行synchronizedMethod方法。

Thread-2尝试进入synchronizedMethod方法，但会被阻塞，因为锁已经被Thread-1持有。

在main方法中，我们在Thread-1获得锁后，尝试中断Thread-2。

尽管Thread-2被中断，它仍然会继续等待锁的释放，而不会抛出InterruptedException。

114. synchronized的不同作用范围有什么区别⭐⭐⭐⭐⭐

synchronized可以应用于实例方法、静态方法和代码块。

同步实例方法

当synchronized用于实例方法时，锁定的是当前对象实例(this)。这意味着同一个对象实例的所有同步实例方法在同一时间只能被一个线程访问。

同一个对象实例的所有同步实例方法在同一时间只能被一个线程访问，不同对象实例之间的同步方法不互相影响。

同步静态方法

当synchronized用于静态方法时，锁定的是该类的Class对象。这意味着同一个类的所有同步静态方法在同一时间只能被一个线程访问。

锁定范围：当前类的Class对象。

影响：同一个类的所有同步静态方法在同一时间只能被一个线程访问，不同类之间的静态方法不互相影响。

同步代码块

当synchronized用于代码块时，可以指定锁定的对象。这提供了更细粒度的控制，可以锁定任意对象。

public class Example {
    private final Object lock = new Object();
    public void method() {
        synchronized (lock) {
            // 代码块
        }
    }
}

锁定范围：指定的锁对象。

影响：只有在访问相同锁对象的同步代码块时，线程才会互相阻塞。可以更灵活地控制锁的粒度。

代码 Demo

public class Example {
    private static final Object classLock = new Object();
    private final Object instanceLock = new Object();
    public synchronized void synchronizedInstanceMethod() {
        // 锁定当前对象实例
    }
    public static synchronized void synchronizedStaticMethod() {
        // 锁定当前类的 Class 对象
    }
    public void methodWithSynchronizedBlock() {
        synchronized (instanceLock) {
            // 锁定 instanceLock 对象
        }
        synchronized (classLock) {
            // 锁定 classLock 对象
        }
    }
}

同步实例方法：锁定当前对象实例，确保同一时间只有一个线程可以访问该对象的同步实例方法。

同步静态方法：锁定当前类的Class对象，确保同一时间只有一个线程可以访问该类的同步静态方法。

同步代码块：锁定指定的对象，可以更灵活地控制锁的粒度，适用于需要更细粒度同步控制的场景。

115. synchronized是可重入锁吗⭐⭐⭐⭐⭐

是的，synchronized是一种可重入锁(Reentrant Lock)。

什么是可重入锁？

可重入锁是指一个线程在持有锁的情况下，可以再次获取该锁而不会被阻塞。这意味着，如果一个线程已经获取了某个锁，它可以再次进入由该锁保护的代码块，而无需重新获取锁。

synchronized的可重入性

在 Java 中，synchronized关键字实现的锁是可重入的。具体来说，如果一个线程已经持有了某个对象的锁，它可以再次进入由该对象锁保护的其他同步方法或同步代码块，而不会被阻塞。这种特性对于实现递归调用和避免死锁非常有用。

public class ReentrantLockExample {
 public synchronized void methodA() {
     System.out.println("Method A start");
     methodB();  // 调用另一个同步方法
     System.out.println("Method A end");
 }
 public synchronized void methodB() {
     System.out.println("Method B start");
     // 其他操作
     System.out.println("Method B end");
 }
 public static void main(String[] args) {
     ReentrantLockExample example = new ReentrantLockExample();
     new Thread(example::methodA).start();
 }
}

在这个例子中，当一个线程调用methodA时，它会首先获取ReentrantLockExample对象的锁。然后，methodA内部调用了methodB，而methodB也是一个同步方法。由于synchronized是可重入的，线程可以进入methodB而不会被阻塞。

输出结果

这个输出结果表明线程在执行methodA时，可以顺利进入methodB，并且在methodB执行完毕后继续执行methodA的剩余部分。

可重入性的意义

1. **递归调用**：如果一个同步方法需要递归调用自身，那么可重入性是必不可少的，否则会导致死锁。
  2. **调用链**：一个同步方法调用另一个同步方法时，如果没有可重入性，同样会导致死锁。
  3. **代码简洁**：可重入性可以使代码更简洁，避免了显式的锁释放和重新获取。

116. 为什么wait和notify必须要在synchronized代码块使用？⭐

主要是为了确保线程间通信的正确性和一致性。

确保对象的监视器锁(Monitor Lock)

wait,notify, 和notifyAll方法是用于线程间通信的，它们依赖于对象的监视器锁(也称为对象锁)。在调用这些方法之前，线程必须持有该对象的监视器锁，否则会抛出IllegalMonitorStateException异常。

public class WaitNotifyExample {
    public synchronized void doWait() {
        try {
            wait(); // 当前线程必须持有对象锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void doNotify() {
        notify(); // 当前线程必须持有对象锁
    }
}

doWait和doNotify方法都在synchronized代码块中执行，以确保当前线程持有对象的监视器锁。

确保线程安全

wait和notify方法用于协调多个线程的执行顺序。如果不在synchronized代码块中使用，这些方法的调用可能会导致竞态条件，破坏线程间的通信协议。

public class IncorrectWaitNotify {
    public void doWait() {
        try {
            wait(); // 非法监视器状态异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void doNotify() {
        notify(); // 非法监视器状态异常
    }
}

在上面的代码中，wait和notify方法不在synchronized代码块中调用，会导致IllegalMonitorStateException，并且无法保证线程间通信的正确性。

保证操作的原子性

wait方法会使当前线程进入等待状态，并释放对象的监视器锁。notify方法会唤醒等待该对象监视器锁的某个线程。如果这些操作不在synchronized代码块中进行，可能会导致以下问题：

竞态条件：多个线程同时检查和修改共享资源，导致数据不一致。

死锁：线程可能会永远等待，因为没有其他线程能够持有对象锁并调用notify。

通过使用synchronized代码块，可以确保这些操作的原子性和一致性。

确保正确的线程唤醒

当一个线程调用wait方法时，它会释放对象的监视器锁并进入等待状态，直到另一个线程调用notify或notifyAll方法。如果不在synchronized代码块中使用，可能会出现以下问题：

早期通知：如果notify方法在wait方法之前调用，等待的线程可能会错过通知，导致永远等待。

丢失通知：如果多个线程竞争调用notify和wait方法，可能会导致通知丢失。

通过在synchronized代码块中使用，可以确保线程在正确的时间点进入等待状态和被唤醒。

代码 Demo

public class WaitNotifyExample {
    private final Object lock = new Object();
    public void doWait() {
        synchronized (lock) {
            try {
                System.out.println("Thread is waiting...");
                lock.wait();
                System.out.println("Thread is resumed.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void doNotify() {
        synchronized (lock) {
            System.out.println("Thread is notifying...");
            lock.notify();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        WaitNotifyExample example = new WaitNotifyExample();
        Thread t1 = new Thread(example::doWait);
        Thread t2 = new Thread(example::doNotify);
        t1.start();
        Thread.sleep(1000); // 确保 t1 先执行
        t2.start();
    }
}

在这个例子中，doWait和doNotify方法都在synchronized代码块中执行，确保了线程间通信的正确性和一致性。

117. synchronized解锁后是如何唤醒其它正在阻塞的线程的？⭐

在 Java 中，当一个线程退出一个 synchronized 块或方法时，它会释放持有的锁。释放锁的操作会触发 JVM 去唤醒等待该锁的线程。具体的唤醒机制由 JVM 实现决定，但通常情况下，当锁被释放时，JVM 会选择一个或多个等待该锁的线程并将其唤醒，使其能够重新竞争锁的获取。

详细过程

锁的获取和释放：

当一个线程进入一个synchronized块或方法时，它会尝试获取该对象的监视器锁(monitor lock)。如果锁已经被其他线程持有，该线程将进入阻塞状态，等待锁被释放。当线程退出synchronized块或方法时，它会释放该监视器锁。

线程的等待和唤醒：

当一个线程在等待synchronized锁时，它会进入阻塞队列(也称为等待队列)。当锁被释放时，JVM 会从阻塞队列中选择一个或多个线程进行唤醒。被唤醒的线程会重新尝试获取锁。如果锁被其他线程抢先获取，唤醒的线程将再次进入阻塞状态，直到锁再次被释放。

JVM 如何选择唤醒的线程

JVM 选择唤醒线程的具体策略可能因不同的 JVM 实现而异，但通常会遵循以下原则：

公平性：某些 JVM 实现可能会尝试实现某种程度的公平性，按照线程进入阻塞队列的顺序进行唤醒。

非公平性：其他实现可能采取非公平的策略，随机选择一个等待的线程进行唤醒。

public class SynchronizedExample {
    private static final Object lock=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1: Holding lock...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Releasing lock...");
            }
        });
        Thread t2=new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Holding lock...");
            }
        });
        t1.start();
        try {
            Thread.sleep(100); // Ensure t1 starts first
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

在这个示例中：

Thread 1首先获取锁并持有它一段时间。

Thread 2尝试获取锁但会被阻塞，直到Thread 1释放锁。

当Thread 1释放锁后，JVM 会唤醒Thread 2，使其能够获取锁并执行同步块中的代码。

118. 什么是可重入锁及使用场景⭐

Java 中的可重入锁

在 Java 中，synchronized关键字和java.util.concurrent.locks.ReentrantLock类都实现了可重入锁的机制。

使用synchronized

public class ReentrantExample {
    public synchronized void outerMethod() {
        System.out.println("In outer method");
        innerMethod();
    }
    public synchronized void innerMethod() {
        System.out.println("In inner method");
    }
    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.outerMethod();
    }
}

outerMethod调用了innerMethod，而innerMethod也被synchronized修饰。由于synchronized是可重入的，线程可以在持有锁的情况下再次进入innerMethod。

使用ReentrantLock

ReentrantLock提供了比synchronized更灵活的锁机制：

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    public void outerMethod() {
        lock.lock();
        try {
            System.out.println("In outer method");
            innerMethod();
        } finally {
            lock.unlock();
        }
    }
    public void innerMethod() {
        lock.lock();
        try {
            System.out.println("In inner method");
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.outerMethod();
    }
}

outerMethod和innerMethod都使用了ReentrantLock。由于ReentrantLock是可重入的，线程可以在持有锁的情况下再次获取锁。

119. 可重入锁实现原理⭐

可重入锁(Reentrant Lock)的实现原理涉及到锁的计数器和线程拥有者的管理。在 Java 中，ReentrantLock是通过java.util.concurrent.locks.AbstractQueuedSynchronizer(AQS)来实现的。

基本原理

可重入锁的基本原理是：

锁计数器：每个线程对锁的获取都会增加锁的计数器，释放锁则会减少锁的计数器。计数器为零时，锁才真正被释放。
线程拥有者：锁记录哪个线程持有它，并且只有持有锁的线程才能重新获取它。

ReentrantLock的实现

ReentrantLock通过内部类Sync来实现锁的具体机制，Sync继承自AbstractQueuedSynchronizer(AQS)。AQS 提供了一套框架，用于实现依赖 FIFO 队列的同步器。

主要成员变量和方法

状态变量：AQS 使用一个volatile的int变量state来表示锁的状态。对于可重入锁，state表示锁的计数器。
当前持有锁的线程：使用Thread变量exclusiveOwnerThread来记录当前持有锁的线程。

120. 锁升级机制是怎样的⭐

锁的升级机制是指锁在不同的竞争条件下从一种状态升级到另一种状态，以优化性能。Java 虚拟机使用了一种称为“偏向锁(Biased Locking)”和“轻量级锁(Lightweight Locking)”的机制来减少锁操作的开销，并在必要时升级到“重量级锁(Heavyweight Locking)”。这种机制在 Java 6 中引入，并在后续版本中不断优化。

锁的状态

1. **无锁(No Lock)**：对象没有被任何线程持有锁。
  2. **偏向锁(Biased Lock)**：锁偏向于第一个获取它的线程，减少无竞争情况下的锁开销。
  3. **轻量级锁(Lightweight Lock)**：在竞争不激烈的情况下使用，通过自旋锁来避免线程阻塞。
  4. **重量级锁(Heavyweight Lock)**：在高竞争情况下使用，涉及操作系统的互斥量(mutex)，会导致线程阻塞和唤醒。

锁升级的具体过程

当一个对象刚刚被创建时，它处于无锁状态。此时，对象头(Object Header)中没有锁相关的信息。

偏向锁是为了优化无竞争情况下的锁操作。当一个线程第一次获取锁时，JVM 会将该线程的 ID 记录在对象头中，并将锁标志位设置为偏向锁。之后，如果同一个线程再次获取锁，无需进行任何同步操作，只需检查对象头中的线程 ID 是否匹配即可。

如果另一个线程尝试获取这个偏向锁，JVM 会撤销偏向锁，升级为轻量级锁。

当偏向锁被撤销或多个线程竞争同一个锁时，JVM 会将锁升级为轻量级锁。轻量级锁使用自旋锁(spinlock)来避免线程阻塞。自旋锁会让线程在短时间内不断尝试获取锁，而不是立即进入阻塞状态。

如果自旋次数超过一定阈值，或者锁竞争变得激烈，轻量级锁会升级为重量级锁。

当锁竞争非常激烈时，轻量级锁会升级为重量级锁，使用操作系统的互斥量(mutex)来进行线程同步。这会导致线程阻塞和唤醒，开销较大。

锁升级的实现细节

锁的升级和降级主要通过对象头(Object Header)中的锁标志位和相关数据结构实现。

对象头(Object Header)：包含锁标志位和其他锁相关信息。

Mark Word：对象头的一部分，用于存储锁信息。根据锁的状态，Mark Word 中的内容会有所不同。

以下是对象头中 Mark Word 的不同状态：

1. **无锁状态**：Mark Word 中包含对象的哈希码(HashCode)等信息。
  2. **偏向锁状态**：Mark Word 中包含偏向线程的 ID。
  3. **轻量级锁状态**：Mark Word 中包含指向栈中锁记录(Lock Record)的指针。
  4. **重量级锁状态**：Mark Word 中包含指向重量级锁(monitor)的指针。