Java笔试面试题AI答之线程（7）

37. 与Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？

与Synchronized相比，可重入锁ReentrantLock的实现原理存在多方面的不同，这些不同主要体现在锁的实现机制、锁的细粒度与灵活性、性能以及使用方式等方面。

1. 锁的实现机制

• Synchronized：是基于JVM层面的锁机制，其实现依赖于JVM内部的Monitor机制。当一个线程进入synchronized修饰的代码块时，会自动获得该对象的锁，并且在退出代码块时自动释放锁。Synchronized在JDK 1.6及以后的版本中，进行了多项优化，包括引入偏向锁、轻量级锁等，以减少锁的开销并提高性能。然而，其底层实现仍然依赖于JVM的Monitor机制，这使得它的行为在某些方面受到限制。

• ReentrantLock：是JDK提供的基于AQS（AbstractQueuedSynchronizer）实现的锁机制。ReentrantLock提供了比synchronized更灵活的锁操作，包括显式地加锁（lock()）、释放锁（unlock()）以及尝试加锁（tryLock()）等操作。此外，ReentrantLock还支持公平锁和非公平锁两种模式，以及条件变量（Condition）等高级功能。其内部通过CAS（Compare-And-Swap）等原子操作来实现锁的获取和释放，避免了线程间的竞争和阻塞。

2. 锁的细粒度与灵活性

• Synchronized：在灵活性方面相对较低，它只能作用于方法或代码块上，并且锁的范围是由JVM在编译时确定的。这意味着一旦synchronized代码块执行完毕，锁就会被释放，无论当前线程是否还需要继续访问该对象的其他同步资源。

• ReentrantLock：提供了更高的灵活性。它可以在代码的任何位置显式地加锁和释放锁，从而可以更精确地控制锁的范围和生命周期。此外，ReentrantLock还支持将多个相关的锁组合成一个锁组（Lock Group），以实现更复杂的同步控制。

3. 性能

• Synchronized：在JDK 1.6及以后的版本中，由于引入了偏向锁和轻量级锁等优化机制，其性能得到了显著提升。在大多数情况下，synchronized的性能已经足够好，甚至可以与ReentrantLock相媲美。然而，在极端高并发场景下，synchronized的性能可能会受到一定影响。

• ReentrantLock：由于其基于AQS实现，并且支持更灵活的锁操作和更高级的同步控制功能，因此在某些场景下可能会表现出更好的性能。特别是在需要精确控制锁的范围和生命周期，或者需要实现复杂的同步控制逻辑时，ReentrantLock的优势更加明显。

4. 使用方式

• Synchronized：使用起来非常简单，只需要在方法或代码块上添加synchronized关键字即可。然而，这也限制了它的灵活性。

• ReentrantLock：使用起来相对复杂一些，需要显式地调用lock()、unlock()等方法来加锁和释放锁。但是，这种显式的方式也提供了更高的灵活性和可控性。此外，ReentrantLock还支持tryLock()等尝试加锁的方法，以及公平锁和非公平锁等高级功能。

综上所述，ReentrantLock与Synchronized在实现原理上存在多方面的不同。在选择使用哪种锁机制时，需要根据具体的应用场景和需求进行权衡和选择。

38. 简述AQS 框架 ？

AQS（AbstractQueuedSynchronizer）是Java中的一个强大的同步框架，它提供了一种基于FIFO（先进先出）等待队列的同步机制，用于管理等待线程并控制资源的获取和释放。AQS是Java并发包（java.util.concurrent）中许多同步类的基础，如ReentrantLock、Semaphore、CountDownLatch等都是基于AQS实现的。以下是AQS框架的简要介绍：

一、核心概念和原理

1. 同步状态（State）：

   • AQS使用一个volatile int类型的变量来表示同步状态。这个状态值在独占锁中通常表示锁是否被某个线程占用，而在共享锁中则表示可以同时访问资源的线程数量。

2. 等待队列（CHL队列）：

   • AQS内部维护了一个FIFO的双向链表作为等待队列，用于存放等待获取同步状态的线程。队列的头部节点表示当前正在尝试获取锁的线程，而尾部节点表示最后加入的等待线程。

3. 节点（Node）：

   • 等待队列中的每个元素都是一个Node节点，它包含了线程的状态信息（如是否被取消、是否需要唤醒后继节点等）、前驱节点和后继节点的引用，以及绑定到该节点的线程。

二、核心方法

AQS定义了一套模板方法，这些方法在AQS中通常被声明为protected，并由子类根据需要进行实现。以下是一些核心方法：

1. acquire(int arg)：

   • 尝试获取同步状态。如果当前线程无法获取同步状态，则将其添加到等待队列中并阻塞。

2. release(int arg)：

   • 释放同步状态，并唤醒等待队列中的后继线程。

3. tryAcquire(int arg)：

   • 尝试获取同步状态，成功则返回true，失败则返回false。这个方法由子类实现，以决定如何获取同步状态。

4. tryRelease(int arg)：

   • 尝试释放同步状态，成功则返回true，失败则返回false。同样由子类实现，以决定如何释放同步状态。

5. tryAcquireShared(int arg)和tryReleaseShared(int arg)：

   • 这两个方法是针对共享锁设计的。tryAcquireShared尝试以共享模式获取同步状态，而tryReleaseShared则尝试以共享模式释放同步状态。

三、资源获取和释放流程

1. 资源获取：

   • 当线程尝试获取同步状态时，首先会调用acquire方法。acquire方法会调用tryAcquire方法尝试获取同步状态。
   • 如果tryAcquire方法返回false，表示当前线程无法立即获取同步状态，则将该线程包装成一个Node节点，并将其添加到等待队列的尾部。
   • 然后，线程会在等待队列中等待，直到被唤醒或中断。

2. 资源释放：

   • 当线程执行完同步代码块后，会调用release方法释放同步状态。
   • release方法会调用tryRelease方法尝试释放同步状态，并唤醒等待队列中的后继线程。

四、适用场景

AQS框架适用于所有单体架构，或者微服务项目中单个服务内部的线程同步和并发控制。它提供了灵活的同步机制，允许开发者根据需要实现自定义的同步器。然而，对于分布式部署的项目，AQS框架并不适用，因为它无法处理跨服务的同步问题。在这种情况下，需要选择适合的分布式锁解决方案，如ZooKeeper、Redisson等。

五、总结

AQS框架是Java并发包中的一个核心部分，它提供了一种基于FIFO等待队列的同步机制，用于管理等待线程并控制资源的获取和释放。通过定义一套模板方法，AQS允许子类根据需要实现自定义的同步器。AQS框架在单体架构和微服务项目中单个服务内部的线程同步和并发控制中发挥着重要作用。

39. 简述AQS 对资源的共享方式？

AQS（AbstractQueuedSynchronizer）是Java并发包中的一个关键框架，用于构建锁和其他同步器。它对资源的共享方式主要分为两种：独占（Exclusive）模式和共享（Shared）模式。这两种模式决定了同步状态（即资源）的获取和释放方式。

1. 独占模式（Exclusive Mode）

定义：

• 独占模式意味着在任何时候，只有一个线程可以持有锁（即获取同步状态），并访问被锁保护的资源。

典型实现：

• 如ReentrantLock，它基于AQS的独占模式实现。在独占模式下，如果线程尝试获取锁（即同步状态）成功，则它独占该资源直到显式释放锁；如果失败，则线程会被加入到AQS的等待队列中，等待其他线程释放锁后再次尝试。

核心方法：

• tryAcquire(int arg)：尝试获取资源。如果成功，则返回true，表示线程获取了锁；如果失败，则返回false，并可能将线程加入到等待队列中。
• tryRelease(int arg)：尝试释放资源。成功释放后，会唤醒等待队列中的下一个线程（如果有的话）。

2. 共享模式（Shared Mode）

定义：

• 共享模式允许多个线程同时获取同步状态，即允许多个线程同时访问被保护的资源。

典型实现：

• 如ReentrantReadWriteLock的读锁部分，以及Semaphore、CountDownLatch等。在共享模式下，每个线程尝试以共享方式获取资源，如果资源足够（比如，在Semaphore中，如果可用的许可数大于0），则线程可以成功获取资源并继续执行；如果资源不足，则线程可能会被加入到等待队列中，等待其他线程释放资源。

核心方法：

• tryAcquireShared(int arg)：尝试以共享方式获取资源。返回值表示是否成功获取资源以及是否有其他线程可以继续获取资源。
• tryReleaseShared(int arg)：尝试释放资源。返回值表示当前状态下其他线程是否可以继续获取资源。

总结

AQS通过提供独占模式和共享模式，以及相应的tryAcquire、tryRelease、tryAcquireShared和tryReleaseShared等方法，允许基于AQS的同步器根据具体需求选择合适的资源共享方式。这种灵活性使得AQS能够适用于广泛的并发场景，实现从基本的互斥锁到复杂的协调器等多种同步需求。在Java的并发包中，许多同步工具类如ReentrantLock、Semaphore、CountDownLatch等都是基于AQS实现的，它们各自通过实现不同的资源共享方式来满足不同的并发控制需求。

40. 如何让 Java 的线程彼此同步？

在Java中，线程同步是确保多个线程在访问共享资源时能够按照预定的顺序或规则执行，以避免数据不一致或线程安全问题的重要机制。Java提供了多种方法来实现线程同步，以下是一些常用的方法：

1. 使用synchronized关键字

synchronized关键字可以用来修饰方法或代码块，以确保在同一时间内只有一个线程可以执行该方法或代码块。

• 修饰方法：当synchronized修饰一个方法时，它会自动对调用该方法的对象加锁，确保同一时刻只有一个线程可以执行该方法。

  public synchronized void myMethod() {
      // 同步代码
  }
  1
  2
  3

• 修饰静态方法：如果synchronized修饰的是静态方法，那么它锁定的是当前类的Class对象，而不是类的某个实例。

  public static synchronized void staticMethod() {
      // 同步代码
  }
  1
  2
  3

• 修饰代码块：有时为了减少同步的开销，只同步方法中的关键部分，可以使用synchronized代码块。

  public void myMethod() {
      synchronized (this) { // 或使用其他对象作为锁
          // 同步代码
      }
  }
  1
  2
  3
  4
  5

2. 使用Lock接口

Java的java.util.concurrent.locks包提供了Lock接口，它比synchronized关键字提供了更灵活的锁控制。Lock接口的实现类（如ReentrantLock）允许显式地获取和释放锁，并支持尝试非阻塞地获取锁、可中断的锁请求、超时等待等功能。

Lock lock = new ReentrantLock();
public void myMethod() {
    lock.lock(); // 获取锁
    try {
        // 同步代码
    } finally {
        lock.unlock(); // 释放锁
    }
}
1
2
3
4
5
6
7
8
9

3. 使用volatile关键字

volatile关键字用于确保变量的读写操作直接发生在主内存中，而不是线程的工作内存中。这保证了所有线程对变量的访问都是一致的，但它不保证复合操作的原子性。

volatile int sharedVar;
1

4. 使用原子类

java.util.concurrent.atomic包中的原子类提供了一种在不使用锁的情况下保证线程安全的替代方案。这些类利用了低级别的硬件原语，提供了一种高效的方式来实现线程安全。

AtomicInteger atomicInt = new AtomicInteger(0);
public void increment() {
    atomicInt.incrementAndGet(); // 原子操作
}
1
2
3
4

5. 使用ThreadLocal类

ThreadLocal类提供了线程局部变量，每个线程都有自己的变量副本，因此不需要同步。这种方法适用于变量只在单个线程内使用的场景。

ThreadLocal<Integer> threadLocalInt = new ThreadLocal<>();
public void setInt(int i) {
    threadLocalInt.set(i); // 每个线程设置自己的值
}
public int getInt() {
    return threadLocalInt.get(); // 每个线程获取自己的值
}
1
2
3
4
5
6
7

6. 使用wait()和notify()/notifyAll()方法

当需要线程间通信时，可以使用wait()和notify()/notifyAll()方法与synchronized关键字一起工作。wait()使一个线程处于等待状态，并释放所持对象的锁；notify()唤醒一个处于阻塞状态的线程；notifyAll()唤醒所有处于阻塞状态的线程。

public synchronized void waitForSignal() throws InterruptedException {
    while (!conditionMet) {
        wait(); // 释放锁并等待
    }
    // 执行操作
}

public synchronized void sendSignal() {
    // 改变条件
    notify(); // 唤醒等待的线程
}
1
2
3
4
5
6
7
8
9
10
11

总结

Java提供了多种机制来实现线程同步，包括synchronized关键字、Lock接口、volatile关键字、原子类和ThreadLocal类。选择哪种机制取决于具体的应用场景和性能要求。正确使用同步机制可以防止数据竞争和死锁，提高程序的稳定性和可靠性。然而，过度同步可能导致性能下降，因此开发者需要仔细权衡同步的范围和粒度。

41. Java中都有哪些同步器?

在Java中，有多种同步器用于实现线程间的同步和协作。这些同步器主要存在于java.util.concurrent包中，为并发编程提供了丰富的工具。以下是一些常用的Java同步器：

1. synchronized关键字：

   • 这是Java提供的一种基本的同步机制，可以用于修饰方法或代码块。当一个线程访问某个对象的synchronized方法或代码块时，它会获得该对象的锁，并阻止其他线程同时访问该对象的synchronized方法或代码块。

2. ReentrantLock：

   • ReentrantLock是一个可重入的互斥锁，与synchronized关键字类似，但它提供了更高的灵活性和控制能力。使用ReentrantLock时，需要显式地获取和释放锁，这可以通过lock()和unlock()方法来实现。此外，ReentrantLock还支持尝试非阻塞地获取锁、可中断的锁请求、超时等待等功能。

3. Semaphore（信号量）：

   • 信号量是一种用于控制同时访问某个特定资源的线程数量的同步器。通过维护一个许可计数器，Semaphore可以控制同时访问资源的线程数。线程可以通过acquire()方法获取许可，如果许可数量为0，则线程将被阻塞直到有许可可用。释放许可则通过release()方法实现。

4. CountDownLatch（计数递减门闩）：

   • CountDownLatch是一个同步工具类，它允许一个或多个线程等待其他线程完成一系列操作后再执行。CountDownLatch初始化时设置一个计数器，任何调用await()方法的线程都会阻塞，直到其他线程调用足够次数的countDown()方法使计数器归零。此时，所有等待的线程都将被唤醒并继续执行。

5. CyclicBarrier（循环栅栏）：

   • CyclicBarrier允许一组线程相互等待，直到所有线程都到达某个屏障点后再同时执行。与CountDownLatch不同的是，CyclicBarrier可以重置并重新使用，因此它更适合用于需要多个线程在多个阶段中相互等待的场景。

6. Phaser（动态阶段同步器）：

   • Phaser是一个更高级的同步器，它提供了比CyclicBarrier更灵活的控制。Phaser可以动态地注册和注销参与者，支持在多个阶段中进行同步，并允许根据需要进行动态调整。这使得Phaser成为处理复杂并发任务时的有力工具。

7. Exchanger（交换器）：

   • Exchanger是一个用于在两个线程之间交换数据的同步器。当一个线程到达交换点时，它会等待另一个线程也到达交换点，然后这两个线程交换数据并继续执行。Exchanger可以用于实现需要两个线程协作完成任务的场景。

8. CompletableFuture：

   • 虽然CompletableFuture本身不是一个传统的同步器，但它提供了一种强大的方式来处理异步编程中的线程同步和协作。CompletableFuture允许你以声明性的方式编写异步代码，并提供了丰富的API来组合、链式调用和处理异步结果。

这些同步器各有特点，适用于不同的并发编程场景。在选择合适的同步器时，需要根据具体的需求和场景来进行权衡和选择。

42. Java 中的线程池是如何实现 ?

Java中的线程池（ThreadPool）是通过java.util.concurrent包中的ExecutorService接口以及它的几个实现类（如ThreadPoolExecutor和ScheduledThreadPoolExecutor）来实现的。线程池是一种基于池化技术的并发框架，它允许你重用一定数量的线程来执行多个任务，从而减少了线程的创建和销毁的开销，提高了系统的性能。

线程池的主要组成部分

1. 核心线程池（Core Pool）：线程池中最基本的线程集合，即使这些线程处于空闲状态，它们也不会被销毁。

2. 工作队列（Work Queue）：当所有核心线程都在忙碌时，新任务将被放置到工作队列中等待执行。Java中常用的工作队列有LinkedBlockingQueue、ArrayBlockingQueue、SynchronousQueue等。

3. 最大线程池（Maximum Pool）：线程池中允许的最大线程数量，包括核心线程和非核心线程。如果工作队列已满，并且已创建的线程数小于最大线程数，线程池会尝试创建新的线程来执行任务。

4. 拒绝策略（Rejected Execution Handler）：当工作队列已满，且已达到最大线程数时，线程池将采取的策略来拒绝新任务。Java提供了几种预定义的拒绝策略，如AbortPolicy（默认策略，直接抛出异常）、CallerRunsPolicy（在调用者的线程中执行任务）、DiscardOldestPolicy（丢弃队列中最旧的任务）、DiscardPolicy（直接丢弃任务，不抛出异常）。

5. 线程工厂（Thread Factory）：用于创建新线程的工厂，可以通过它设置创建的线程的优先级、名称、是否为守护线程等。

线程池的实现原理

线程池的实现主要依赖于ThreadPoolExecutor类，它实现了ExecutorService接口。当你向线程池提交一个任务时，线程池会首先检查核心线程池是否已满，如果未满，则直接创建一个新线程来执行任务；如果已满，则进一步检查工作队列是否已满，如果未满，则将任务添加到工作队列中等待执行；如果工作队列也满了，则检查最大线程池是否已满，如果未满，则创建一个新的非核心线程来执行任务；如果都满了，则根据配置的拒绝策略来处理任务。

线程池的使用

Java提供了几种便捷的线程池创建方法，如Executors工厂类提供的newFixedThreadPool（固定大小的线程池）、newCachedThreadPool（可缓存的线程池）、newSingleThreadExecutor（单线程的线程池）等。这些方法都是基于ThreadPoolExecutor类的封装，简化了线程池的创建过程。

注意事项

• 线程池的大小需要根据实际任务量和系统资源来合理配置，过大或过小的线程池都可能导致性能问题。
• 提交给线程池的任务最好是轻量级的，避免执行时间过长或占用资源过多的任务，以免影响线程池的性能。
• 线程池的生命周期需要妥善管理，确保在不再需要时能够正确关闭线程池，释放资源。

答案来自文心一言，仅供参考