多线程面试专题

---

多线程的用途

1. 充分利用多核CPU的优势

   • 随着技术的进步，现代计算机通常拥有多核CPU。通过多线程，可以使不同的核心同时处理不同的任务，从而充分发挥多核CPU的性能优势。

2. 防止阻塞

   • 在单核CPU上，多线程可能会导致线程上下文切换而降低效率。然而，在单核CPU上使用多线程仍然有其价值，主要是为了防止阻塞。通过多线程并行执行，即使其中一个线程阻塞，也不会影响其他线程的执行。

3. 便于建模

   • 将大型任务分解为多个小任务，并使用多线程同时处理这些小任务，可以使程序的建模更加简单明了。这种方法能够降低复杂度，并提高程序的可维护性和可扩展性。

线程和进程主要区别

1. 地址空间：

   • 进程有独立的地址空间，即每个进程都有自己独立的虚拟内存空间，不同进程之间的内存空间是隔离的，一个进程的崩溃不会影响其他进程。
   • 线程是进程内的执行单元，线程共享所属进程的地址空间，即所有线程都可以访问相同的内存地址，包括全局变量等。因此，线程之间可以方便地共享数据。

2. 资源开销：

   • 在创建和销毁过程中，进程通常会比线程消耗更多的资源，包括内存、CPU时间和操作系统的资源。
   • 线程的创建和销毁通常比进程更快，因为它们共享相同的地址空间，不需要像进程那样复制大量的资源。

3. 并发性和共享性：

   • 进程之间的通信需要额外的机制，例如管道、消息队列、共享内存等。
   • 线程之间可以通过共享内存等机制直接访问彼此的数据，因此线程间的通信更加高效简便。

4. 健壮性：

   • 由于进程有独立的地址空间，一个进程的崩溃通常不会影响其他进程，因此多进程程序相对较为健壮。
   • 线程共享相同的地址空间，一个线程的错误可能会影响到其他线程，使得多线程程序的健壮性相对较低。

实现线程的方式有几种

1. 继承 Thread 类实现多线程：

   • 这种方式是通过继承Thread类并重写其run()方法来实现多线程。然后通过创建Thread的实例并调用start()方法来启动线程。

2. 实现 Runnable 接口方式实现多线程：

   • 这种方式是创建一个实现了Runnable接口的类，并实现其run()方法。然后通过创建Thread的实例，将Runnable对象传递给Thread的构造函数来启动线程。

3. 使用 ExecutorService、Callable、Future 实现有返回结果的多线程：

   • 这种方式可以实现有返回结果的多线程任务。通过ExecutorService框架中的线程池来管理线程的执行，通过Callable接口来定义任务，并返回Future对象以获取线程执行的结果。

启动线程方法 start()和 run()有什么区别？

1. start()方法：
   • 当调用start()方法时，系统会为该线程分配新的调用栈，然后在新的调用栈中执行线程的run()方法。这样会使得线程在新的调用栈中并行执行，表现出多线程的特性。
   • 启动线程后，该线程将异步执行，与其他线程并发执行。

Thread myThread = new MyThread();
myThread.start(); // 启动线程

2. run()方法：
   • 直接调用run()方法并不会启动一个新的线程，而是在当前线程的调用栈上顺序执行run()方法内的代码。这样会导致run()方法内的代码与其他代码同步执行，而不是并行执行。
   • 直接调用run()方法时，线程执行的过程会被阻塞，直到run()方法内的代码执行完毕。

Thread myThread = new MyThread();
myThread.run(); // 直接调用run()方法，线程的代码将在当前线程中顺序执行

总的来说，调用start()方法会启动一个新的线程并异步执行run()方法内的代码，表现出多线程的特性；而直接调用run()方法则是在当前线程中同步执行run()方法内的代码，不具备多线程的特性。

怎么终止一个线程？如何优雅地终止线程

1. 使用标志位：在线程的执行过程中，定期检查一个标志位，当标志位为true时，线程自然退出。

class MyThread extends Thread {
    private volatile boolean running = true;

    public void run() {
        while (running) {
            // 线程执行的任务
        }
    }

    public void stopThread() {
        running = false;
    }
}

2. 使用interrupt()方法：调用线程的interrupt()方法来中断线程，线程会抛出InterruptedException异常，可以捕获这个异常并在合适的地方退出线程。

class MyThread extends Thread {
    public void run() {
        while (!Thread.interrupted()) {
            // 线程执行的任务
        }
    }
}

3. 使用Thread.interrupted()方法：在线程的执行过程中定期调用Thread.interrupted()方法检查线程的中断状态，当返回true时，线程自然退出。

class MyThread extends Thread {
    public void run() {
        while (!Thread.interrupted()) {
            // 线程执行的任务
        }
    }
}

4. 使用join()方法：在主线程中调用子线程的join()方法，主线程会等待子线程执行完成后再继续执行。

Thread myThread = new MyThread();
myThread.start();
myThread.join(); // 主线程等待子线程执行完成

这些方法都可以使线程在不使用stop()方法的情况下优雅地终止，保证线程的资源得到正确释放，避免可能的数据损坏或者死锁等问题。

一个线程的生命周期包括以下几种状态

1. NEW（新建状态）：表示线程已经被创建，但还没有启动。此时线程对象已经存在，但尚未调用start()方法。

2. RUNNABLE（运行状态）：表示线程已经启动并且正在运行，可以是正在执行任务，或者正在等待CPU调度执行。

3. BLOCKED（阻塞状态）：表示线程由于竞争锁资源而被阻塞。当线程试图获取一个已经被其他线程持有的锁时，它会进入BLOCKED状态。

4. WAITING（等待状态）：表示线程正在等待另一个线程执行特定操作。线程在调用wait()方法、join()方法等待其他线程的通知或者结束时会进入此状态。

5. TIMED_WAITING（计时等待状态）：与WAITING状态类似，但是具有一定的时间限制。线程在调用sleep()方法、带有超时参数的wait()方法、join()方法等待一段时间后会进入此状态。

6. TERMINATED（终止状态）：表示线程已经执行完毕，结束生命周期。线程可以因为run()方法执行完毕而自然结束，也可以由于异常或者手动调用stop()方法而结束。

线程在这些状态之间的转换如下：

• 从NEW状态转换到RUNNABLE状态，通过调用start()方法启动线程。
• RUNNABLE状态可能会转换为BLOCKED状态（获取锁失败）、WAITING状态（调用了wait()或join()方法）或者TIMED_WAITING状态（调用了sleep()方法等待）。
• BLOCKED状态会在获取锁成功后转换为RUNNABLE状态。
• WAITING状态和TIMED_WAITING状态会在等待特定条件满足后转换为RUNNABLE状态。
• RUNNABLE状态执行完成后会转换为TERMINATED状态，或者在执行过程中抛出异常而终止。
• 一旦线程进入TERMINATED状态，就不能再转换为其他状态。

线程中的 wait()和 sleep()方法有什么区别？

wait()方法和sleep()方法都可以让线程暂停执行一段时间，但它们之间有一些重要的区别：

1. wait()方法：

   • wait()方法是Object类中的方法，在线程执行时可以调用该方法使线程进入等待状态，并释放对象的锁。
   • 当线程调用wait()方法时，它会暂时释放持有的对象监视器（即锁），并等待其他线程调用notify()或notifyAll()方法来唤醒它，或者等待指定的等待时间过去。
   • wait()方法通常在多线程中用于线程间的协调和通信。

2. sleep()方法：

   • sleep()方法是Thread类的静态方法，用于让当前线程休眠一段指定的时间。
   • 调用sleep()方法时，线程不会释放它所持有的任何对象的锁。
   • sleep()方法通常用于线程的暂停或者简单的时间延迟操作。

总结：

• wait()方法必须在同步块（synchronized）中调用，而sleep()方法可以在任何地方调用。
• wait()方法会释放对象的监视器，sleep()方法不会释放任何锁。
• wait()方法需要被唤醒才能继续执行，而sleep()方法会在指定的时间过去后自动恢复执行。
• wait()方法和sleep()方法都可以用于线程间的协调，但目的和使用场景不同。

多线程同步有哪几种方法？

多线程同步有多种方法，其中常见的包括：

1. Synchronized关键字：
   • 使用synchronized关键字可以实现对代码块或方法的同步，确保同一时刻只有一个线程可以执行被同步的代码。
   • synchronized关键字可以用来修饰方法或代码块，当线程进入被synchronized修饰的方法或代码块时，它会尝试获取对象的监视器锁（即锁定对象），其他线程必须等待该线程释放锁后才能执行。

public synchronized void synchronizedMethod() {
    // 同步方法
}

public void synchronizedBlock() {
    synchronized(this) {
        // 同步代码块
    }
}

2. Lock接口实现：
   • 使用java.util.concurrent.locks包中的Lock接口及其实现类（如ReentrantLock）来实现线程同步。
   • 与synchronized关键字相比，Lock提供了更多的灵活性和功能，例如可以实现公平锁、可中断锁、超时锁等。

Lock lock = new ReentrantLock();

public void synchronizedMethod() {
    lock.lock();
    try {
        // 同步方法
    } finally {
        lock.unlock();
    }
}

3. 分布式锁：
   • 在分布式系统中，多个节点之间需要协调对共享资源的访问。分布式锁是一种在分布式环境下实现同步的方法，常见的实现包括基于Redis、ZooKeeper等的分布式锁方案。

// 以Redis为例，通过setnx()等命令实现分布式锁

这些方法都可以实现多线程之间的同步，开发者可以根据具体的需求和场景选择合适的同步方式。

什么是死锁？如何避免死锁？

死锁是指两个或多个线程在执行过程中，由于竞争资源或者互相等待对方释放资源而造成的一种阻塞状态，导致线程无法继续执行下去，进而陷入无限等待的状态。

典型的死锁场景如下：

• 线程A持有资源X，等待获取资源Y。
• 线程B持有资源Y，等待获取资源X。
• 由于线程A和线程B相互等待对方释放资源，导致两个线程都无法继续执行下去，从而发生死锁。

为了避免死锁的发生，可以采取以下几种策略：

1. 避免嵌套锁：尽量减少锁的层次嵌套，尽量使用单一的锁进行资源的管理。

2. 按固定顺序获取锁：在多个线程获取多个锁的情况下，约定好获取锁的顺序，按照相同的顺序获取锁可以减少死锁的发生。

3. 使用tryLock()方法：在获取锁时，使用tryLock()方法而不是直接使用synchronized关键字或者lock()方法，因为tryLock()方法可以设置超时时间，避免长时间等待锁而引发死锁。

4. 使用Lock的超时机制：在使用Lock接口实现的锁时，可以使用tryLock(long time, TimeUnit unit)方法来获取锁，设置一个超时时间，当获取锁失败时不再等待。

5. 避免线程持有锁的同时还等待其他锁：在持有一个锁的同时，不要在等待其他锁，以减少死锁的发生。

6. 资源分配的策略：设计良好的资源分配策略，避免出现循环等待的情况，尽量减少资源竞争。

通过以上策略，可以有效地避免死锁的发生，提高多线程程序的健壮性和稳定性。

多线程之间如何进行通信？

在Java中，多线程之间可以通过wait()和notify()方法进行通信。这两个方法是Object类中的方法，用于实现线程之间的协调和通知。

1. wait()方法：
   • wait()方法用于使当前线程进入等待状态，并释放对象的监视器锁。调用wait()方法的线程会暂停执行，直到其他线程调用相同对象的notify()或notifyAll()方法来唤醒它，或者等待指定的时间过去。
   • wait()方法通常用于等待其他线程的操作结果或者特定条件的满足。

synchronized (obj) {
    while (condition) {
        obj.wait(); // 当前线程等待
    }
}

2. notify()方法和notifyAll()方法：
   • notify()方法用于唤醒在相同对象上调用wait()方法而进入等待状态的一个线程。如果有多个线程在等待，notify()方法只会唤醒其中一个线程，具体唤醒哪个线程是不确定的。
   • notifyAll()方法用于唤醒在相同对象上调用wait()方法而进入等待状态的所有线程。

synchronized (obj) {
    obj.notify(); // 唤醒一个等待的线程
    // 或者使用 obj.notifyAll() 唤醒所有等待的线程
}

通过wait()和notify()方法，线程可以进行有效的通信和协作，实现线程间的同步和互斥操作。需要注意的是，wait()和notify()方法必须在同步块或者同步方法中调用，并且针对同一对象进行调用。

violatile 关键字的作用？

volatile 关键字在 Java 中的作用主要有两个方面：

1. 可见性：使用 volatile 修饰的变量，保证了其在多线程之间的可见性。也就是说，每次读取到 volatile 变量时，都能获取到最新的数据。这是因为 volatile 会强制将修改的值立即写入主存，当其他线程读取该变量时，都会去主存中读取新值。

2. 禁止指令重排序：在 JVM 进行即时编译时，为了提高性能，可能会对指令进行重排序。但是在多线程环境下，这可能会导致一些意想不到的问题。使用 volatile 可以禁止这种语义上的重排序，从而保证程序的正确性。需要注意的是，这也可能会降低代码的执行效率。

volatile 的一个重要作用就是和 CAS（Compare And Swap）操作结合，保证了原子性。

新建 T1、T2、T3 三个线程，如何保证它们按顺序执行？

可以使用 join() 方法。join() 方法会使当前线程等待调用 join() 方法的线程执行完毕后再继续执行。

怎么控制同一时间只有 3 个线程运行？

可以使用Java中的Semaphore（信号量）来控制同时只有3个线程运行。
Semaphore是一种基于计数的同步工具，可以用于控制同时访问某个资源的线程个数。

为什么要使用线程池？

使用线程池的主要原因包括：

1. 减少资源消耗：线程池中的线程可以被重复利用，避免了频繁创建和销毁线程的开销，节约了系统资源。

2. 提高响应速度：线程池中的线程已经预先创建好，当有任务到达时，可以立即执行，而不需要等待新线程的创建。

3. 提高系统性能：通过控制线程的数量和管理任务队列，线程池可以更好地控制系统的并发度，避免过多的线程竞争资源，提高系统的吞吐量和性能表现。

4. 提供线程管理和监控：线程池提供了丰富的API和管理机制，可以方便地监控线程池的状态、调整线程数量和配置等，有利于系统的管理和维护。

5. 避免内存泄漏：如果手动创建的线程没有正确地销毁，容易导致内存泄漏，而线程池能够自动管理线程的生命周期，及时回收资源，避免内存泄漏问题。

常用的几种线程池包括

1. FixedThreadPool（固定大小线程池）：
   • FixedThreadPool是一种固定大小的线程池，在初始化时会创建指定数量的线程，并且线程池大小不会发生变化。
   • 当有新任务提交时，如果线程池中有空闲线程，则立即执行；如果所有线程都在执行任务，新任务会进入等待队列等待执行。

ExecutorService executor = Executors.newFixedThreadPool(3);

2. CachedThreadPool（缓存线程池）：
   • CachedThreadPool是一种根据需要创建新线程的线程池，线程池的大小可以根据任务数量的变化动态调整。
   • 当有新任务提交时，如果线程池中有空闲线程，则立即执行；如果所有线程都在执行任务，则创建新线程来处理新任务。

ExecutorService executor = Executors.newCachedThreadPool();

3. SingleThreadPool（单线程池）：
   • SingleThreadPool是一种只有一个工作线程的线程池，保证所有任务按照指定顺序执行。
   • 当有新任务提交时，如果线程池中有空闲线程，则立即执行；如果当前线程正在执行任务，则新任务会进入等待队列等待执行。

ExecutorService executor = Executors.newSingleThreadExecutor();

工作原理：

• 线程池在初始化时会创建指定数量的线程，并维护一个任务队列来存储待执行的任务。
• 当有新任务提交时，线程池会根据具体的策略来决定是否创建新线程来处理任务，或者将任务放入队列等待执行。
• 如果线程池中有空闲线程，则立即执行任务；如果所有线程都在执行任务，则根据具体的策略来决定是等待还是创建新线程来处理任务。
• 线程执行完任务后，会返回线程池，可以继续处理其他任务或者等待新任务的到来。
• 当线程池不再需要时，可以调用shutdown()方法关闭线程池，线程池会等待所有任务执行完成后再关闭。如果需要立即关闭线程池，并且取消所有正在执行的任务，可以调用shutdownNow()方法。

总的来说，线程池可以更好地管理线程的生命周期和执行任务，提高系统的性能和资源利用率，避免资源耗尽和性能瓶颈。根据实际需求选择合适的线程池类型和参数配置，可以有效地优化多线程应用的性能和稳定性。

线程池启动线程 submit()和 execute()方法有什么不同？

您已经描述得很清楚了。确实，execute()方法和submit()方法在功能上有一些不同：

1. execute()方法：
   • execute()方法用于提交一个Runnable任务给线程池执行，没有返回值。
   • 如果任务执行过程中抛出了异常，异常将会在控制台输出，但主线程无法感知到这个异常。
   • 因为execute()方法没有返回值，所以无法获得任务执行的结果。

executor.execute(new RunnableTask());

2. submit()方法：
   • submit()方法用于提交一个Runnable或者Callable任务给线程池执行，有返回值，返回一个Future对象。
   • 如果提交的是Runnable任务，它的返回值是一个Future对象，通过Future对象可以判断任务是否执行完成、取消任务执行、获取任务执行结果等。
   • 如果提交的是Callable任务，它的返回值就是Callable任务执行的结果，可以通过Future对象的get()方法获取。

Future<String> future = executor.submit(new CallableTask());

总的来说，如果不需要获取任务的执行结果，可以使用execute()方法，简单方便；如果需要获取任务的执行结果，或者想要捕获任务执行过程中的异常，可以使用submit()方法。

CyclicBarrier 和 CountDownLatch 的区别？

CyclicBarrier和CountDownLatch的区别总结：

1. 作用：

   • CyclicBarrier用于多个线程之间相互等待，直到所有线程都达到了某个同步点，然后继续执行。它适用于一组线程需要等待其他线程达到共同的中间状态，然后再继续执行。
   • CountDownLatch用于一个或多个线程等待其他一组线程完成操作，它是一种单向的计数器，用来控制某个任务等待其他所有任务执行完成之后再执行。

2. 线程等待：

   • CyclicBarrier中的线程会在达到同步点后停止运行，直到所有线程都到达同步点后重新开始运行。
   • CountDownLatch中的线程会继续运行，只是在某个任务完成时会将计数值减一。

3. 唤起任务：

   • CyclicBarrier只能唤起一个任务，即所有线程都到达同步点时，会执行指定的Runnable任务。
   • CountDownLatch可以在计数值为0时唤起多个任务。

4. 重用性：

   • CyclicBarrier是可重用的，一旦所有线程都到达同步点，它会重置计数器，可以继续使用。
   • CountDownLatch是不可重用的，一旦计数值为0，就无法再次使用。

总的来说，CyclicBarrier适合多个线程之间相互等待，直到所有线程都到达同一点再继续执行，而CountDownLatch适合一个或多个线程等待其他一组线程完成操作后再执行。另外，CyclicBarrier是可重用的，而CountDownLatch不可重用。

什么是活锁、饥饿、无锁、死锁？

1. 死锁（Deadlock）：

   • 多个线程相互等待对方持有的资源，导致所有线程都无法继续执行，形成僵局。
   • 死锁的发生通常需要满足四个条件：互斥条件、请求与保持条件、不可剥夺条件和循环等待条件。

2. 活锁（Livelock）：

   • 多个线程因为相互让步而无法继续执行，导致线程的执行状态在不断改变，但没有任何线程能够继续执行下去。

3. 饥饿（Starvation）：

   • 某个线程无法获取到所需的资源，因此无法继续执行，即使它一直处于就绪状态，但始终无法获得执行的机会。

4. 无锁（Lock-Free）：

   • 多个线程可以在不使用显式锁的情况下访问共享资源，通过一种特殊的并发控制机制，如CAS（Compare and Swap）等。
   • 无锁的设计能够避免锁带来的性能瓶颈和线程之间的阻塞，但也可能导致一些并发问题，需要谨慎使用。

以上是关于死锁、活锁、饥饿和无锁的基本概念和区别。在编写多线程应用程序时，理解这些概念是非常重要的，以避免出现不良的并发行为。

什么是原子性、可见性、有序性？

1. 原子性：

   • 原子性是指一个操作是不可中断的，要么执行完毕，要么没有执行，中间不会被其他线程打断。
   • 在多线程编程中，需要使用原子操作来确保对共享资源的操作是原子的，如使用AtomicInteger等线程安全的类。

2. 可见性：

   • 可见性是指一个线程修改了共享变量的值后，其他线程能够立即看到这个修改后的值。
   • 在多线程环境中，由于每个线程都有自己的工作内存，修改的值可能会暂时保存在工作内存中，其他线程无法立即看到修改后的值，需要通过特定的同步机制来保证可见性。

3. 有序性：

   • 有序性是指程序的执行顺序与代码的顺序一致，即代码按照书写顺序依次执行。
   • 在多线程环境中，由于指令重排序等优化，程序的执行顺序可能会发生变化，但这种重排序不会影响单个线程的执行结果，只是可能会影响多个线程之间的交互。

总的来说，原子性、可见性和有序性是多线程编程中需要特别注意的问题，合理使用同步机制、volatile关键字和原子类等工具可以有效地解决这些问题，确保多线程程序的正确性和性能。

什么是守护线程？有什么用？

守护线程（Daemon Thread）是一种在后台运行的线程，其作用是为其他线程提供服务和支持。与用户线程相对应的是守护线程，守护线程通常在后台默默地执行一些任务，它们并不是程序中的核心线程，当所有的用户线程结束后，守护线程也会随之自动结束。以下是关于守护线程的一些重要特点和用途：

1. 特点：

   • 守护线程并不是程序中的关键线程，它们的生命周期不会影响整个程序的运行。
   • 当所有的用户线程结束后，守护线程会自动退出，不会阻碍程序的正常结束。
   • 守护线程通常用于执行一些后台任务，如垃圾回收、日志记录等。

2. 用途：

   • 执行后台任务：守护线程通常用于执行一些不需要用户干预的后台任务，如垃圾回收、定时任务等。
   • 提供服务支持：守护线程可以为其他线程提供服务和支持，如监控和管理其他线程的运行状态。

总的来说，守护线程是一种在后台默默执行任务的线程，其生命周期受到用户线程的影响，当所有的用户线程结束后，守护线程也会随之自动结束。它们通常用于执行后台任务和为其他线程提供服务支持，是多线程编程中的重要组成部分。

一个线程运行时发生异常会怎样？

当一个线程运行时发生异常但没有被捕获，通常会导致以下情况发生：

1. 线程停止执行：未捕获的异常会导致线程停止执行，这可能会影响到整个应用程序的运行。

2. 异常传播：未捕获的异常会沿着线程调用栈向上传播，直到遇到合适的异常处理机制为止。如果最终未被处理，该线程将被终止。

为了处理未捕获的异常，可以通过以下方式：

• 使用try-catch块捕获异常：在线程的run()方法中使用try-catch块来捕获可能出现的异常，从而避免异常未被捕获导致线程终止。

• 设置线程的未捕获异常处理器（Uncaught Exception Handler）：通过设置线程的UncaughtExceptionHandler来处理未捕获的异常。当线程抛出未捕获的异常时，会调用UncaughtExceptionHandler的uncaughtException()方法来处理异常，从而使程序能够更加灵活地处理异常情况。

总的来说，未捕获的异常可能会导致线程终止执行，因此在编写多线程应用程序时，要确保适当地处理异常情况，以保证程序的稳定性和健壮性。

线程 yield()方法有什么用？

yield()方法是Thread类的一个静态方法，调用它会暂停当前正在执行的线程，并让其他具有相同优先级的线程有机会执行。然而，yield()方法并不保证其他线程一定会被执行，它只是告诉调度器当前线程愿意让出CPU资源，而其他线程是否会被调度取决于调度器的具体实现。

yield()方法的主要作用是提高线程间的协调性，通常在以下情况下使用：

1. 当线程需要等待一段时间后再继续执行，可以调用yield()方法将CPU让给其他线程，以避免占用CPU资源而导致不必要的等待。
2. 当线程执行的任务较为轻量级且具有较高的响应性要求时，可以通过调用yield()方法提高系统的响应速度。

需要注意的是，使用yield()方法并不能确保线程调度的精确性和确定性，它只是一种提示调度器的方式，具体的线程调度仍然取决于调度器的实现和环境因素。

什么是重入锁？

重入锁（Reentrant Lock）是一种支持同一个线程多次获得锁的锁机制。当线程获取了重入锁之后，如果再次尝试获取该锁，它就会成功获取，而不会被阻塞。这种机制允许线程在持有锁的情况下多次进入同步代码块，从而避免了死锁的发生。

重入锁的主要特点包括：

1. 可重入性：同一个线程可以多次获得同一把锁，而不会被阻塞。这种特性使得重入锁更容易管理和使用。

2. 公平性：重入锁支持公平和非公平的锁获取方式。公平性表示锁的获取按照线程的申请顺序进行，而非公平性则允许新请求的线程插队获取锁。

3. 可中断性：重入锁支持线程的中断操作，即在等待锁的过程中可以中断等待线程的执行。

4. 超时性：重入锁支持尝试获取锁的超时机制，即线程尝试获取锁时可以设置一个超时时间，在超过指定时间后如果未能获取到锁，则放弃获取。

重入锁通常比synchronized关键字更加灵活，更容易满足复杂的线程同步需求，但也需要手动释放锁，避免造成死锁等问题。在Java中，重入锁主要通过ReentrantLock类来实现。

Synchronized 有哪几种用法？

在Java中，synchronized关键字有三种主要的用法：

1. 锁方法：使用synchronized修饰方法，使得整个方法成为一个同步代码块。当某个线程进入这个方法时，会自动获取该方法所属对象的锁，并在方法执行完毕或抛出异常后释放锁。其他线程在该方法上加锁时会被阻塞，直到锁被释放。

   public synchronized void synchronizedMethod() {
       // 同步方法的代码块
   }
   

2. 锁代码块：使用synchronized关键字将代码块包裹起来，只对代码块中的部分代码进行同步控制。当某个线程进入该代码块时，会获取到指定对象的锁，并在执行完该代码块后释放锁。其他线程可以同时访问对象中未被synchronized修饰的代码块。

   public void someMethod() {
       synchronized (this) {
           // 需要同步的代码块
       }
   }
   

3. 锁类：使用synchronized修饰静态方法或代码块，使得整个类的所有实例对象共享同一把锁。当某个线程进入该静态方法或静态代码块时，会获取该类的Class对象对应的锁，其他线程无法同时访问该类的其他静态方法或静态代码块。

   public class SomeClass {
       public static synchronized void staticSynchronizedMethod() {
           // 静态同步方法的代码块
       }
   }
   

这三种用法都可以实现对共享资源的线程安全访问，但需要根据具体的需求和情况选择合适的方式。

Fork/Join 框架是干什么的？

Fork/Join框架是Java中用于实现并行计算的框架之一，它主要用于将一个大任务拆分成多个小任务并行执行，然后将各个子任务的结果合并得到最终结果。Fork/Join框架的核心是ForkJoinPool、ForkJoinTask和RecursiveTask。

具体来说，Fork/Join框架的功能包括以下几点：

1. 任务拆分：Fork/Join框架能够将一个大任务拆分成多个小任务，这样可以更好地利用多核处理器的并行计算能力。

2. 任务执行：Fork/Join框架通过ForkJoinPool管理多个工作线程，每个工作线程执行一个任务。这些任务可能是被拆分的子任务，也可能是其他类型的任务。

3. 并行计算：Fork/Join框架会自动将任务分配给多个工作线程并行执行，从而提高整体的计算性能。

4. 合并结果：一旦所有子任务完成，Fork/Join框架会将各个子任务的结果合并成一个最终结果。这个过程通常是递归的，即不断将子任务的结果合并成更大的结果，直到得到最终的计算结果。

Fork/Join框架适用于需要进行大规模并行计算的场景，例如递归分治算法、归并排序、图像处理等。通过利用Fork/Join框架，可以简化并行计算的实现过程，提高程序的性能和效率。

线程数过多会造成什么异常？

在Java应用程序中，创建过多的线程可能会导致以下几种异常：

1. OutOfMemoryError： 如果创建大量线程而没有足够的内存来支持这些线程的栈空间，就会导致内存溢出异常。每个线程都有自己的栈空间，用于存储局部变量、方法调用和执行状态。如果线程数量过多，每个线程的栈空间占用的内存总和可能超出了可用内存限制，从而导致OutOfMemoryError异常。

2. 资源竞争： 过多的线程竞争有限的系统资源，如CPU时间、内存和I/O资源，可能导致资源争夺和竞争条件，进而影响程序的性能和稳定性。这种情况下，线程之间可能会出现频繁的上下文切换，降低了系统的吞吐量和效率。

3. 系统负载过高： 如果创建大量的线程，系统可能无法有效地管理这些线程，导致系统负载过高。这会影响系统的响应速度，甚至导致系统崩溃或无法正常工作。

4. 性能下降： 虽然多线程可以提高程序的并发性和性能，但如果线程数量过多，也会带来额外的开销，如线程创建和销毁的时间、线程上下文切换的开销等，从而导致性能下降。

因此，在设计多线程应用程序时，需要合理评估和控制线程数量，避免过多线程的创建和使用，以确保程序的稳定性、性能和可维护性。

说说线程安全的和不安全的集合

线程安全的集合

线程安全的集合是指在多线程环境下，多个线程可以安全地并发访问集合而不会出现数据不一致或其他线程安全问题。Java中提供了一些线程安全的集合类，例如：

1. ConcurrentHashMap： 是HashMap的线程安全版本，它通过分段锁（Segment）来实现并发访问，不同的线程可以同时读取不同的分段，从而提高了并发性能。

2. CopyOnWriteArrayList/CopyOnWriteArraySet： 它们是ArrayList和HashSet的线程安全版本，采用了写时复制的策略，在写操作时复制一份新的数据副本，读操作则直接读取旧的数据副本，从而保证了线程安全。

3. ConcurrentLinkedQueue/ConcurrentLinkedDeque： 是队列和双端队列的线程安全实现，基于无锁的算法，适合高并发环境。

线程不安全的集合

线程不安全的集合是指在多线程环境下，多个线程同时对集合进行读写操作时可能导致不一致性、异常或数据丢失等问题。例如：

1. HashMap/HashSet： 这些集合类不是线程安全的，多个线程同时对它们进行并发读写操作可能导致数据丢失、死循环或其他异常。

2. ArrayList/LinkedList： ArrayList和LinkedList也不是线程安全的，如果多个线程同时对它们进行修改或迭代操作，可能会导致ConcurrentModificationException异常或其他不一致问题。

3. HashMap作为单例对象的成员变量： 如果多个线程共享同一个HashMap实例，并且对其进行并发修改，可能会导致数据不一致或其他线程安全问题。

因此，在多线程环境中，应当尽量使用线程安全的集合类，或者采用合适的同步手段（如锁、并发工具类）来保证集合的线程安全性，以避免出现数据不一致或其他并发问题。

什么是 CAS 算法？在多线程中有哪些应用。

CAS（Compare and Swap）算法是一种原子操作，用于实现并发编程中的同步机制。它的基本思想是在执行更新操作之前，先比较当前内存中的值是否与预期值相匹配，如果相匹配，则执行更新操作；如果不匹配，则不执行更新操作，直接返回失败。CAS 算法的执行过程是原子性的，即在同一时刻只有一个线程可以成功执行更新操作。

在多线程中，CAS 算法常用于实现非阻塞式的并发控制，通常用于解决并发情况下的共享资源访问问题。Java中的CAS操作主要通过java.util.concurrent.atomic包下的原子类实现，例如：

1. AtomicInteger/AtomicLong/AtomicBoolean： 这些原子类提供了对整型、长整型和布尔型变量的原子操作，包括CAS算法所需的compareAndSet方法。

2. AtomicReference： 用于实现引用类型的原子操作，比如更新对象引用。

3. AtomicArray/AtomicIntegerFieldUpdater/AtomicReferenceFieldUpdater： 分别用于对数组、字段的原子操作，允许对数组和对象的字段进行原子更新。

CAS算法在多线程编程中的应用非常广泛，主要用于实现以下场景：

• 无锁数据结构： CAS算法可以实现一些无锁的数据结构，如非阻塞队列、无锁链表等，避免了使用锁带来的性能损耗和线程阻塞。

• 并发控制： CAS算法可以用于实现一些并发控制机制，如自旋锁、原子变量、乐观锁等，保证多个线程对共享资源的访问的原子性和线程安全性。

• ABA问题的解决： CAS算法通常结合版本号等机制来解决ABA问题，确保在修改共享变量时不会出现其他线程的干扰。

总的来说，CAS算法通过乐观锁的方式实现了并发控制，避免了传统锁机制的一些性能瓶颈和线程阻塞问题，因此在多线程编程中具有重要的应用价值。

怎么检测一个线程是否拥有锁？

方法 java.lang.Thread#holdsLock(Object) 可以用于检测当前线程是否拥有指定对象的锁。该方法接受一个对象作为参数，并返回一个布尔值，指示当前线程是否持有该对象的监视器锁。如果当前线程持有该对象的锁，则返回 true，否则返回 false。

以下是该方法的使用示例：

public class LockDetectionExample {
    private final Object lock = new Object();

    public void doSomething() {
        if (Thread.holdsLock(lock)) {
            System.out.println("当前线程持有锁");
        } else {
            System.out.println("当前线程未持有锁");
        }
    }

    public static void main(String[] args) {
        LockDetectionExample example = new LockDetectionExample();
        
        // 在 synchronized 块内部检测
        synchronized (example.lock) {
            example.doSomething(); // 输出 "当前线程持有锁"
        }

        // 在 synchronized 块外部检测
        example.doSomething(); // 输出 "当前线程未持有锁"
    }
}

在示例中，doSomething() 方法内部通过 Thread.holdsLock(lock) 方法检测当前线程是否持有 lock 对象的锁，并输出相应的信息。

Jdk 中排查多线程问题用什么命令？

jstack 命令是用于生成 Java 虚拟机当前线程堆栈跟踪的命令。通过执行 jstack 命令，可以获取 Java 进程中各个线程的堆栈信息，从而用于排查多线程问题。

一般情况下，可以使用以下命令格式来使用 jstack：

jstack <pid>

其中，<pid> 是 Java 进程的进程 ID。执行该命令后，会输出 Java 进程中各个线程的堆栈信息，包括线程的状态、调用栈等，可以通过分析这些信息来诊断多线程相关的问题，如死锁、线程阻塞等。

此外，还可以使用 jstack 命令的其他选项和参数来进行更详细的线程堆栈跟踪，例如 -l 选项可以输出更详细的堆栈信息。

线程同步需要注意什么？

1. 减小同步范围：尽量只在需要同步的关键代码段内部使用锁，避免将整个方法或代码块都锁定，以提高系统的并发性和吞吐量。

2. 分布式同步锁：在分布式系统中，单纯的线程同步锁无法解决跨多个节点的同步问题。此时需要使用分布式锁，以确保跨节点之间的数据一致性和同步操作的正确性。

3. 防止死锁：死锁是多线程编程中的常见问题，特别是在涉及多个锁的情况下。为了避免死锁，需要注意加锁的顺序，尽量避免嵌套锁以及交叉锁定多个资源。此外，使用定时锁等机制可以在发生死锁时自动解锁，避免系统长时间阻塞。

除了上述注意事项外，还有一些其他的线程同步方面的注意事项，例如避免过多的锁竞争、避免长时间持有锁、及时释放锁等，都是确保线程同步正确性和性能的重要因素。

线程 wait()方法使用有什么前提？

使用 wait() 方法的前提条件是在同步块或同步方法中调用。这是因为 wait() 方法需要获取对象的监视器（即锁），以确保在等待期间其他线程不会修改共享资源的状态，从而避免出现竞态条件或不一致性的情况。

当线程调用 wait() 方法时，它会释放当前持有的锁，并进入等待状态，直到被其他线程调用 notify() 或 notifyAll() 方法唤醒，或者等待超时或中断。因此，为了避免出现 IllegalMonitorStateException 异常，wait() 方法必须在已经获取锁的情况下调用，通常在使用 synchronized 关键字或 Lock 对象进行同步的代码块或方法中使用。

Fork/Join 框架使用有哪些要注意的地方？

除了系统线程数量堆积和栈内存溢出之外，使用Fork/Join框架还有其他需要注意的地方：

1. 任务拆分粒度： 需要谨慎确定任务的拆分粒度。如果任务过小，拆分的开销可能超过任务本身的计算开销，导致性能下降；如果任务过大，可能无法充分利用多核处理器的优势，导致负载不均衡。

2. 递归任务调用： 在使用Fork/Join框架时，避免在任务内部递归调用自身或其他任务，这可能会导致死锁或栈溢出。

3. IO操作： Fork/Join框架适用于CPU密集型任务，对于IO密集型任务不太适合。如果任务中包含IO操作，可能会出现线程阻塞，导致其他线程无法执行，降低性能。

4. 异常处理： 需要注意异常处理。在Fork/Join任务中，如果一个子任务抛出了异常而未被捕获，那么整个任务会被取消，并且该异常会被传播到join操作的地方。

5. 并行度控制： 要根据实际情况合理控制并行度。Fork/Join框架默认使用处理器的所有核心来执行任务，但是有时候可能需要限制并行度，以避免资源过度竞争或者系统负载过重的情况。

6. 任务依赖性： 当任务之间存在依赖关系时，需要谨慎设计任务的拆分和合并逻辑，以确保任务能够按照正确的顺序执行，否则可能会导致错误的结果。

综上所述，使用Fork/Join框架需要谨慎设计任务的拆分粒度、异常处理、并行度控制等方面，以确保系统能够充分利用多核处理器的性能优势，并且避免出现性能下降或其他意外情况。

线程之间如何传递数据？

线程之间可以通过共享对象来传递数据，常见的方式包括：

1. 共享内存： 多个线程共享同一个内存空间，在内存中创建共享的数据结构，通过对共享数据的读写实现线程间数据传递。

2. wait/notify/notifyAll： 使用wait/notify/notifyAll机制，在线程之间进行等待和唤醒的通信，配合共享对象进行数据传递。

3. Lock/Condition： 使用显示的锁（如ReentrantLock）和条件变量（Condition），通过await/signal/signalAll方法进行线程间的等待和唤醒，以及数据传递。

4. 阻塞队列（BlockingQueue）： 使用阻塞队列作为共享数据的缓冲区，在队列中存储需要传递的数据，生产者线程往队列中放入数据，消费者线程从队列中取出数据，实现线程间的数据传递。

5. ThreadLocal： 使用ThreadLocal实现线程间的数据隔离，每个线程都可以独立访问自己的ThreadLocal变量，从而避免了线程间数据共享带来的同步问题。

这些方法各有优缺点，根据具体的场景和需求选择合适的方式进行线程间数据传递。

保证"可见性"有哪几种方式？

除了synchronized和volatile之外，还有几种保证可见性的方式：

1. Atomic 原子类： Java.util.concurrent.atomic 包提供了一系列的原子类，如AtomicInteger、AtomicLong等，它们提供了一些原子操作，保证了多线程环境下的可见性和原子性。

2. Lock 接口及其实现类： 使用显示锁（如ReentrantLock）进行同步，可以通过lock和unlock方法来保证可见性。

3. Thread.join()： 在一个线程中调用另一个线程的join方法，会使得当前线程阻塞，直到被调用的线程执行完毕，这样可以保证被调用线程对共享变量所做的修改对当前线程可见。

4. ThreadLocal 变量： 每个线程都拥有自己独立的ThreadLocal变量，这样线程间不会相互影响，从而保证了可见性。

5. 使用并发容器（ConcurrentHashMap、CopyOnWriteArrayList等）： Java.util.concurrent 包提供了一系列线程安全的并发容器，它们内部采用了一些机制来保证多线程环境下的可见性。

这些方式可以根据具体的需求和场景来选择，以保证共享数据的可见性。

说几个常用的 Lock 接口实现锁。

除了ReentrantLock和ReadWriteLock之外，还有一些其他常用的Lock接口实现锁，例如：

1. StampedLock： Java 8 引入的StampedLock，是一种基于乐观读的机制，提供了三种模式：读模式、写模式和乐观读模式，可用于替代ReentrantReadWriteLock，适用于读多写少的场景。

2. LockSupport： LockSupport类是用来创建锁和其他同步类的基本线程阻塞原语。它可以创建类似于synchronized的同步块和类似于Object.wait的等待方法。它比使用Object.wait/notify的优势是LockSupport不用进行同步，不用获取锁，所以非常高效。

3. Condition： Condition是JUC提供的一种条件对象，它可以让线程在某个条件满足时进入等待状态，并在条件发生变化时被唤醒。它通常与ReentrantLock结合使用，通过Lock的newCondition()方法获取。

4. Semaphore： Semaphore是一种基于计数的信号量，用来控制对互斥资源的访问。它和锁的区别在于，锁是一次只允许一个线程访问共享资源，而Semaphore允许多个线程同时访问共享资源，但是要控制并发访问的线程数量。

这些Lock接口的实现提供了更灵活、更高级的锁定机制，可以根据具体的场景和需求来选择使用。

ThreadLocal 是什么？有什么应用场景？

ThreadLocal 是 Java 中的一个特殊的线程封闭技术，它允许我们创建的变量只能被同一个线程读写，而不会被其他线程读写。每个线程都拥有自己独立的变量副本，互不影响。

应用场景包括但不限于：

1. 数据库连接管理： 在多线程环境下，为了避免多个线程共享同一个数据库连接对象而引发的并发访问问题，可以使用 ThreadLocal 来管理数据库连接，保证每个线程都拥有独立的数据库连接。

2. 会话管理： Web 应用中，通常会将用户的会话信息存储在 Session 对象中，为了避免多个线程共享同一个 Session 对象而引发的并发访问问题，可以使用 ThreadLocal 来在每个线程中存储和管理自己的 Session 对象。

3. 线程上下文信息传递： 在框架或库中，有时需要在线程间传递一些上下文信息，例如用户身份认证信息、请求信息等，可以使用 ThreadLocal 来存储和传递这些信息，避免显式参数传递的复杂性。

4. 简化代码： 在一些场景下，为了避免方法之间频繁传递参数，可以使用 ThreadLocal 来存储方法之间需要共享的数据，从而简化代码逻辑。

总之，ThreadLocal 可以在多线程环境下提供一种线程封闭的机制，有效地解决了线程间数据共享和线程安全的问题。

ReadWriteLock 有什么用？

ReadWriteLock 接口和它的实现类 ReentrantReadWriteLock 提供了一种读写分离的锁机制，可以有效提高多线程环境下读操作的并发性能。其主要作用包括：

1. 读写分离： ReadWriteLock 接口允许多个线程同时获取读锁，只有当线程持有读锁时，其他线程才能继续获取读锁，这样可以实现多个线程同时读取共享资源而不会互斥。而写锁是独占的，当一个线程持有写锁时，其他线程无法获取读锁或写锁，从而保证写操作的原子性和一致性。

2. 提高并发性能： 在读多写少的场景下，使用读写锁可以显著提高程序的并发性能。读锁是共享的，多个线程可以同时获取读锁而不会阻塞，只有当有线程持有写锁时，其他线程才会被阻塞。这种读写分离的机制可以减少写操作对读操作的影响，提高了程序的并发处理能力。

3. 降低锁竞争： 由于读锁是共享的，多个线程可以同时获取读锁，而不会发生竞争，从而降低了锁的争用情况。只有在写操作发生时才会有锁的竞争，这样可以减少锁的粒度，提高了系统的吞吐量。

总之，ReadWriteLock 提供了一种读写分离的锁机制，适用于读多写少的场景，可以有效地提高多线程环境下读操作的并发性能，降低锁的竞争，提高系统的吞吐量。

FutureTask 是什么？

FutureTask 是 Java 中表示异步计算结果的一种机制，通常用于表示一个可以获取结果的异步任务。它可以包装一个 Callable 或 Runnable 对象，用于在未来的某个时刻执行，并返回计算结果。

主要特点包括：

1. 表示异步计算： FutureTask 是表示异步计算结果的一种机制，它可以包装一个 Callable 或 Runnable 对象，用于执行异步计算任务。

2. 获取计算结果： 可以通过调用 FutureTask 的 get() 方法来等待异步计算的完成，并获取计算结果。如果计算尚未完成，get() 方法会阻塞当前线程，直到计算完成并返回结果。

3. 判断计算状态： 可以通过 isDone() 方法判断异步计算是否完成，通过 isCancelled() 方法判断是否已取消。

4. 取消任务： 可以通过 cancel() 方法取消异步任务的执行。当调用 cancel() 方法时，如果任务尚未开始执行，则会尝试取消任务的执行，并返回 true；如果任务已经开始执行或已经执行完成，则无法取消，并返回 false。

FutureTask 的灵活性和功能丰富性使其成为处理异步任务和获取异步计算结果的常用工具之一。

怎么唤醒一个阻塞的线程？

唤醒一个阻塞的线程的方法取决于线程被阻塞的原因。在 Java 中，主要的线程阻塞情况包括等待某个条件的发生、睡眠一段时间、等待其他线程完成等。针对不同的阻塞情况，可以采用以下方法之一来唤醒线程：

1. wait() 方法阻塞： 如果线程调用了对象的 wait() 方法而被阻塞，可以通过调用相同对象的 notify() 或 notifyAll() 方法来唤醒被阻塞的线程。notify() 方法唤醒一个等待该对象锁的线程，而 notifyAll() 方法则唤醒所有等待该对象锁的线程。

2. sleep() 方法阻塞： 如果线程调用了 sleep() 方法而被阻塞，可以通过调用 interrupt() 方法来中断线程的睡眠状态，从而唤醒线程。当线程处于睡眠状态时，调用 interrupt() 方法会抛出 InterruptedException 异常，可以在异常处理代码中恢复线程执行。

3. join() 方法阻塞： 如果线程调用了另一个线程的 join() 方法而被阻塞，可以通过等待另一个线程执行完成来唤醒被阻塞的线程。当另一个线程执行完成时，join() 方法返回，被阻塞的线程即可继续执行。

4. IO 阻塞： 如果线程因为进行 IO 操作而被阻塞，如读写文件、网络通信等，Java 代码无法直接唤醒被阻塞的线程。这种情况下，可以通过关闭相应的 IO 流或者连接来间接地中断 IO 操作，从而使线程解除阻塞。

总之，唤醒一个阻塞的线程通常涉及到中断阻塞状态、改变等待条件或者等待超时时间到期等操作，具体的方法取决于线程被阻塞的原因和使用的同步机制。

不可变对象对多线程有什么帮助？

1. 线程安全性： 不可变对象的状态在创建后无法修改，因此不会出现线程安全问题。多个线程可以同时访问不可变对象而无需进行额外的同步措施，从而避免了竞态条件和数据争用问题。

2. 内存可见性： 不可变对象的状态一经初始化就不会发生变化，这意味着对不可变对象的修改对其他线程是立即可见的。因此，不需要使用 synchronized 或 volatile 等机制来确保对对象状态的修改对其他线程的可见性。

3. 无需同步开销： 由于不可变对象不会发生状态变化，因此不需要进行同步操作，避免了同步带来的性能开销和线程竞争。

4. 简化并发编程： 使用不可变对象可以减少在编写并发程序时需要考虑的线程安全问题。因为不可变对象的状态是固定的，不会受到外部环境的影响，因此编写和维护线程安全的代码变得更加简单和可靠。

总的来说，不可变对象在多线程环境中能够提供更好的线程安全性、更高的性能和更简单的编程模型，因此在并发编程中被广泛应用。

多线程上下文切换是什么意思？

多线程上下文切换发生在多个线程之间共享 CPU 资源的情况下。当一个线程在执行过程中，如果发生了某些事件（比如时间片耗尽、线程被阻塞、线程主动让出 CPU 等），操作系统会暂停当前线程的执行，保存该线程的上下文信息（比如寄存器状态、程序计数器值等），然后从就绪队列中选择另一个线程来执行，同时将选中线程的上下文信息加载到 CPU 中，使其继续执行。

这个过程就是上下文切换。上下文切换的目的是使多个线程在 CPU 上轮流执行，从而实现并发执行的效果。上下文切换会消耗一定的时间和系统资源，因此在设计和优化多线程应用程序时，需要尽量减少上下文切换的次数，以提高系统的性能和效率。

Java 中用到了什么线程调度算法？

在 Java 中，线程调度算法主要由操作系统负责，Java 本身并没有直接实现线程调度算法。操作系统会根据自身的调度策略来分配 CPU 时间片给不同的线程，以实现多线程之间的并发执行。常见的线程调度算法包括抢占式调度和非抢占式调度。

在抢占式调度算法中，操作系统会根据线程的优先级和调度策略来决定下一个执行的线程。如果一个线程的优先级较高，或者它已经等待了一段时间而未被执行（避免饥饿），那么操作系统可能会优先选择这个线程来执行，而暂停当前执行的线程。

在 Java 中，可以通过设置线程的优先级（Thread.setPriority）来影响线程的调度顺序，但具体的调度算法和策略仍由操作系统负责。因此，在编写 Java 程序时，通常无法直接控制线程的调度算法，而是依赖于操作系统的实现。

Thread.sleep(0)的作用是什么？

在Java中，Thread.sleep(0)的作用是将当前线程从运行状态转为阻塞状态，然后立即重新竞争CPU执行权。这个操作会让其他具有相同或更高优先级的线程有机会获取CPU执行权，从而提高了系统的公平性。

具体来说，Thread.sleep(0)会暂停当前线程的执行，将CPU执行权交给其他具有相同或更高优先级的线程。如果没有其他线程处于可运行状态或者没有更高优先级的线程，那么当前线程会立即重新被调度执行。

需要注意的是，Thread.sleep(0)并不会导致当前线程睡眠任何时间，它的作用仅仅是触发一次操作系统的线程调度，让其他线程有机会运行。

Java 内存模型是什么，哪些区域是线程共享的，哪些是不共享的？

Java内存模型（Java Memory Model，JMM）定义了Java虚拟机（JVM）在计算机内存中的工作方式，以及线程如何与内存交互的规则。JMM规定了在多线程编程环境下，线程如何访问共享内存以及如何在不同线程之间保证内存可见性、有序性和原子性。

在Java内存模型中，有以下几种内存区域是线程共享的：

1. 堆（Heap）：堆是用于存储对象实例的内存区域，在堆中分配的对象可以被所有线程访问。堆是Java虚拟机管理的最大一块内存区域，存放着几乎所有的对象实例和数组对象。
2. 方法区（Method Area）：方法区用于存储类的结构信息、运行时常量池、静态变量、类的字节码等数据，是各个线程共享的内存区域。

而以下几种内存区域是线程私有的：

1. 程序计数器（Program Counter Register）：程序计数器是每个线程私有的，用于指示当前线程正在执行的字节码指令的地址。
2. 虚拟机栈（VM Stack）：虚拟机栈也是每个线程私有的，用于存储方法的局部变量、操作数栈、动态链接、方法出口等信息。
3. 本地方法栈（Native Method Stack）：本地方法栈也是每个线程私有的，用于支持本地方法（native方法）的执行。

以上是Java内存模型的基本内容，对于开发人员来说，了解Java内存模型对于编写正确、高效的多线程程序非常重要。

什么是乐观锁和悲观锁？

乐观锁和悲观锁是两种不同的并发控制机制，用于处理多个线程同时访问共享资源的情况。

1. 乐观锁：

   • 乐观锁假设多个线程之间的冲突是不常见的，因此不加锁直接进行操作。
   • 乐观锁通常基于版本号（Versioning）或时间戳（Timestamp）机制实现，每个数据项都会有一个版本号或时间戳。
   • 在读取数据时，不会加锁，但会记录下读取数据时的版本号或时间戳。
   • 在更新数据时，会比较当前的版本号或时间戳与之前读取时记录的版本号或时间戳，如果一致则更新成功，否则表示其他线程已经修改了数据，此时可能需要进行重试或者放弃操作。
   • 乐观锁适用于读操作远远多于写操作的场景，以及写操作冲突较少的场景。

2. 悲观锁：

   • 悲观锁假设多个线程之间的冲突是常见的，因此在操作前会先加锁，保证只有一个线程能够访问共享资源。
   • synchronized 关键字就是悲观锁的一种典型实现，通过对代码块或方法进行加锁，确保同一时间只有一个线程能够执行加锁的代码块或方法。
   • 悲观锁适用于写操作频繁的场景，或者对数据一致性要求比较高的场景。

总的来说，乐观锁和悲观锁各有适用的场景，选择合适的锁机制可以提高程序的并发性能和数据的一致性。

Hashtable 的 size()方法为什么要做同步？

Hashtable 的 size() 方法要做同步是为了确保多个线程在调用 size() 方法时能够获取到准确的元素个数。在并发环境下，如果不进行同步，可能会出现以下情况：

1. 多个线程同时调用 size() 方法，如果其中一个线程正在对 Hashtable 进行修改（比如添加或删除元素），而其他线程同时在读取元素个数，可能会读取到不一致的结果。

2. 如果在读取元素个数的过程中，有其他线程正在修改 Hashtable 的结构（比如添加或删除元素），可能会导致读取到不正确的元素个数。

为了避免以上情况，Hashtable 在实现 size() 方法时采用了同步机制，确保在同一时刻只能有一个线程访问 Hashtable 的结构，从而保证了 size() 方法的准确性。虽然同步会造成一定的性能损失，但在多线程环境下，保证数据的一致性和准确性比性能更为重要。

同步方法和同步块，哪种更好？

在选择使用同步方法（synchronized 方法）和同步块（synchronized 块）时，通常要根据具体情况来决定哪种更好。下面是一些考虑因素：

1. 粒度控制：同步块允许你更细粒度地控制需要同步的代码块，可以避免不必要的锁竞争和性能损耗。如果只需要对某一部分代码进行同步，而不是整个方法，使用同步块会更合适。

2. 代码可读性：同步方法会将整个方法体包装在同步块中，这样可能会更简洁清晰，尤其是对于简单的同步需求。但是，如果同步逻辑比较复杂，可能会使方法变得冗长难懂。相比之下，使用同步块可以更明确地指定需要同步的代码块，提高了代码的可读性。

3. 性能影响：在某些情况下，同步方法可能会导致性能问题，特别是在方法体中包含了大量耗时操作时。因为同步方法会锁住整个方法，即使其中只有一小部分需要同步，其他线程也会被阻塞。相比之下，同步块可以减小锁的粒度，提高了并发性能。

综上所述，如果只需要对整个方法进行同步，且方法体逻辑简单清晰，可以考虑使用同步方法。但是，如果需要更精细地控制同步范围，或者需要提高并发性能，使用同步块可能更合适。

什么是自旋锁？

自旋锁是一种基于忙等待的锁机制，在尝试获取锁时，线程不会立即被阻塞，而是会在循环中反复尝试获取锁，直到成功获取为止，或者超过一定的尝试次数。

自旋锁的特点包括：

1. 忙等待：线程在获取锁失败时会一直循环尝试获取锁，不会被挂起，因此称为忙等待。

2. 无阻塞：自旋锁尝试获取锁时不会导致线程阻塞，所以适用于短时间内持有锁的情况，避免了线程切换和上下文切换的开销。

3. 低延迟：由于自旋锁不会导致线程阻塞和切换，因此在高并发情况下，自旋锁通常具有较低的延迟。

自旋锁的缺点是在高并发情况下可能会引起“活锁”问题，即多个线程反复尝试获取锁而导致CPU资源浪费，因此在实际应用中需要慎重选择自旋锁的使用场景，并且通常会设置最大自旋次数或者采用其他更复杂的锁机制来解决“活锁”问题。

Runnable 和 Thread 用哪个好？

在Java中，Runnable接口和Thread类都用于创建线程，它们各自有不同的使用场景和优缺点。

1. Runnable 接口：

   • 实现 Runnable 接口的类可以避免Java单继承的限制，因为它们仍然可以扩展其他类。
   • 适合多个线程共享相同的实例，因为它可以作为一个任务在多个线程之间共享。
   • 提供了更好的代码结构和可维护性，因为它将任务的定义与线程的管理分离开来，使得代码更清晰。
   • 使用 Runnable 可以更好地利用线程池来管理和重用线程，从而提高性能和资源利用率。

2. Thread 类：

   • 继承 Thread 类创建线程可能更简单直观，因为它是面向对象的方式创建线程。
   • 对于简单的线程需求，例如执行简单的任务或示例代码，直接继承 Thread 类可能更方便。
   • 使用 Thread 类可以方便地重写其 run() 方法，使得任务的执行逻辑更紧密地与线程绑定在一起。

综上所述，对于大多数情况，推荐使用 Runnable 接口来创建线程，因为它提供了更好的灵活性、可维护性和性能。只有在一些简单的情况下，或者需要直接控制线程的创建和管理时，才考虑直接继承 Thread 类。

Java 中 notify 和 notifyAll 有什么区别？

1. notify() 方法：

   • notify() 方法用于唤醒等待在当前对象监视器（即锁）上的一个线程，但是具体是哪一个线程被唤醒是不确定的。这取决于JVM的实现，通常是等待时间最长的线程。
   • 如果没有线程等待或者所有等待线程都被唤醒，notify() 方法不会有任何效果。

2. notifyAll() 方法：

   • notifyAll() 方法用于唤醒等待在当前对象监视器上的所有线程，让它们重新进入就绪状态，并且开始争夺锁。
   • 当有多个线程等待同一个锁并且需要被唤醒时，通常使用 notifyAll() 方法以确保所有等待线程都有机会获取锁。

在使用 notify() 和 notifyAll() 时，需要特别注意避免产生死锁或不必要的线程唤醒，以免导致程序的性能问题或逻辑错误。

为什么 wait/notify/notifyAll 这些方法不在 thread 类里面？

1. 锁的粒度：

   • 在 Java 中，锁是与对象相关联的，而不是与线程相关联的。因此，等待、通知和唤醒的操作应该与持有锁的对象相关联，而不是与线程本身相关联。
   • wait()、notify() 和 notifyAll() 方法是与对象监视器（即锁）相关的操作，它们需要与某个特定的对象关联，以便在等待、通知和唤醒线程时能够正确地协调锁的状态。

2. 线程的职责：

   • 线程应该专注于执行任务而不是管理同步机制。将等待和通知的方法放在 Thread 类中可能会导致混乱和不必要的耦合。将这些方法放在 Object 类中使得它们更加与锁相关联，而不是与线程本身相关联，从而更好地符合 Java 中对象导向的设计原则。

3. 灵活性和可重用性：

   • 将等待和通知的方法定义在 Object 类中增加了灵活性和可重用性。任何类都可以拥有自己的同步区域，并通过调用 wait()、notify() 和 notifyAll() 来实现线程之间的协作，而不仅限于 Thread 类。

综上所述，将等待和通知的方法定义在 Object 类中使得它们更加与锁相关联，更符合面向对象的设计原则，并且增加了灵活性和可重用性。

为什么 wait 和 notify 方法要在同步块中调用？

1. 强制要求：Java API 要求在调用 wait()、notify() 或 notifyAll() 方法之前必须获取对象的监视器锁（即在同步块或同步方法中调用）。否则，会抛出 IllegalMonitorStateException 异常。

2. 避免竞态条件：在同步块中调用 wait()、notify() 或 notifyAll() 可以避免出现竞态条件。竞态条件可能会导致线程在调用 wait() 方法之后立即被唤醒，而此时还没有其他线程调用 notify() 或 notifyAll() 方法来通知它。通过将这些方法调用放在同步块中，可以确保线程在释放锁之前被正确地唤醒。

因此，为了符合 Java API 的规范并避免竞态条件，我们应该在同步块中调用 wait()、notify() 或 notifyAll() 方法。

为什么你应该在循环中检查等待条件？

在循环中检查等待条件是非常重要的，因为在等待状态中的线程可能会在未满足条件的情况下被唤醒，这种情况被称为“虚假唤醒”（spurious wakeup）。这可能是由于操作系统或 JVM 内部的某些实现细节导致的。如果不在循环中检查等待条件，那么线程在醒来后可能会错误地认为条件已经满足，然后继续执行下去，这可能导致程序逻辑出错或者数据不一致的情况发生。

因此，在使用 wait() 方法时，通常会在一个循环中检查等待条件，确保线程在被唤醒后再次检查条件，只有在条件满足时才继续执行。这样可以有效地防止虚假唤醒带来的问题，保证线程等待和唤醒的正确性。

Java 中堆和栈有什么不同？

堆（Heap）和栈（Stack）是 Java 虚拟机内存管理的两个主要区域，它们在内存管理和数据存储方面有着不同的特点和作用。

1. 存储内容：

   • 堆（Heap）：堆是 Java 虚拟机管理的一个大内存池，用于存储对象实例和数组对象。在堆中分配的内存由 Java 垃圾回收器管理，用于存储动态创建的对象，它的生命周期和对象的生命周期是不一样的，当没有任何引用指向一个对象时，该对象就会被垃圾回收器回收。
   • 栈（Stack）：栈是线程私有的，用于存储基本数据类型的变量、对象引用和方法调用的局部变量表。每个线程都有自己的栈空间，栈的内存分配和释放都是自动进行的，方法调用时会创建一个栈帧，栈帧中包含了方法的局部变量、操作数栈和其他与方法调用相关的数据。

2. 内存分配和回收：

   • 堆：由 Java 虚拟机动态管理，对象的内存分配和回收都是自动进行的。当对象不再被引用时，Java 垃圾回收器会自动回收该对象占用的内存。
   • 栈：栈空间由 Java 虚拟机自动分配和释放，栈中的内存是基于方法的调用和返回，具有先进后出（LIFO）的特性。

3. 存储大小：

   • 堆：堆是 Java 虚拟机管理的一块较大的内存池，一般比栈空间大得多，用于存储动态创建的对象。
   • 栈：栈是线程私有的，每个线程都有自己的栈空间，栈空间通常比较小，大小由 Java 虚拟机预先分配。

4. 数据共享：

   • 堆：堆是所有线程共享的内存区域，可以被多个线程访问和修改。
   • 栈：栈是线程私有的，每个线程都有自己独立的栈空间，栈中的数据只能被拥有该栈的线程访问和修改。

在 Java 编程中，栈一般用于存储局部变量和方法调用，而堆用于存储对象实例。对于基本类型的变量，通常会存储在栈中，而对象的引用会存储在栈上，而对象本身则存储在堆中。

你如何在 Java 中获取线程堆栈？

在 Java 中获取线程堆栈可以使用以下几种方式：

1. 使用 jstack 命令：jstack 是 JDK 自带的一个命令行工具，可以用来输出 Java 进程中各个线程的堆栈信息。你可以通过以下步骤来使用 jstack：

   jstack <pid>
   

   其中 <pid> 是 Java 进程的进程 ID。

2. 使用 kill -3 命令（适用于 Unix/Linux 系统）：在 Unix/Linux 系统上，你可以使用 kill -3 命令给 Java 进程发送 SIGQUIT 信号，从而导出线程堆栈信息：

   kill -3 <pid>
   

   其中 <pid> 是 Java 进程的进程 ID。

3. 使用 VisualVM：VisualVM 是一个基于图形界面的 Java 虚拟机监控和性能分析工具，它可以用来监控 Java 应用程序的运行情况，并且可以通过 VisualVM 直观地查看和分析线程堆栈信息。

4. 使用代码：在 Java 程序中，你也可以通过编写代码来获取线程堆栈信息。可以使用 Thread 类的 getAllStackTraces() 方法来获取当前 Java 虚拟机中所有线程的堆栈信息。

这些方法都可以用来获取 Java 进程中线程的堆栈信息，你可以根据实际情况选择适合的方式来使用。

如何创建线程安全的单例模式？

创建线程安全的单例模式可以通过以下几种方式实现：

1. 饿汉式单例模式（线程安全）：

public class Singleton {
    // 在类加载时就创建实例，保证了线程安全
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

在这种方式中，INSTANCE 实例在类加载时就被创建，因此可以保证线程安全。

2. 懒汉式单例模式（双重检查锁）：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这种方式在第一次调用 getInstance() 方法时才会创建实例，通过双重检查锁机制（double-checked locking）确保了线程安全。

3. 静态内部类单例模式：

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

通过静态内部类的方式，可以实现懒加载并保证线程安全，因为静态内部类在类加载时会被初始化，保证了线程安全性。

这些方式都可以保证在多线程环境下获取单例实例时的线程安全性。

什么是阻塞式方法？

阻塞式方法是一种在调用过程中会暂时挂起当前线程，直到某个条件满足或者操作完成才会继续执行的方法。在阻塞式方法中，当前线程会被挂起，不会执行其他操作，直到被阻塞的条件被满足或者操作完成后才会继续执行。

典型的阻塞式方法包括：

1. I/O 阻塞：例如 InputStream 和 OutputStream 的读写操作，以及 ServerSocket 的 accept() 方法等。当没有数据可读或者没有新的连接时，这些方法会阻塞线程直到有新数据可读或者有新的连接到达。

2. 线程等待：例如 Object 类的 wait() 方法。当一个线程调用 wait() 方法时，它会进入等待状态，并释放对象锁，直到其他线程调用了相同对象的 notify() 或 notifyAll() 方法才会被唤醒。

在阻塞式方法中，当前线程的执行会暂停，直到某个条件满足或者操作完成。这种方法适用于需要等待外部条件满足的情况，但在处理阻塞时需要注意避免死锁和资源浪费等问题。

提交任务时线程池队列已满会时发会生什么？

当线程池队列已满时，如果线程数小于最大线程池大小（maximumPoolSize），则线程池会创建新的线程来处理任务，直到线程数达到最大线程池大小为止。这样可以确保任务不会被丢弃，而是会有足够的线程来处理。

但是，当线程数已经达到最大线程池大小时，如果继续有新的任务提交到线程池，线程池就会执行拒绝策略。拒绝策略决定了在无法处理新任务时线程池应该采取的操作，常见的拒绝策略包括：

1. AbortPolicy（默认）：直接抛出 RejectedExecutionException 异常，拒绝新任务的提交。

2. CallerRunsPolicy：由提交任务的线程来执行该任务。这种策略可以保证任务不会丢失，但可能会导致提交任务的线程被阻塞，因为它需要执行新任务。

3. DiscardPolicy：直接丢弃无法处理的新任务，不做任何处理。这种策略可能会导致部分任务被丢弃。

4. DiscardOldestPolicy：丢弃队列中等待时间最长的任务，然后尝试将新任务加入队列。这样可以尽可能保留新任务，但可能会丢弃一些等待时间较长的任务。

选择合适的拒绝策略取决于应用程序的需求和业务场景，需要根据具体情况进行调整。