Java高手的30k之路｜面试宝典｜精通多线程（一）

最新推荐文章于 2024-10-30 18:07:32 发布
最新推荐文章于 2024-10-30 18:07:32 发布
阅读量903 收藏 18
点赞数 23
分类专栏： Java高手的30k之路 面试攻略 JAVA 文章标签： java 面试 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41379244/article/details/139757367
版权

基础概念

线程与进程

1. 进程与线程的区别

进程（Process）：

  • 定义：进程是程序的一次执行实例，包含了程序的代码和当前活动的状态。进程是操作系统分配资源的基本单位。
  • 独立性：进程之间是相互独立的，每个进程都有自己的内存空间和系统资源。
  • 开销：创建和切换进程的开销较大，因为涉及到上下文切换和资源分配/回收。
  • 通信：进程之间的通信通常需要借助操作系统提供的进程间通信（IPC）机制，如管道、消息队列、共享内存等。

线程（Thread）：

  • 定义：线程是进程中的一个执行单元，是 CPU 调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存、文件描述符等）。
  • 共享性：同一进程内的线程可以共享进程的资源（如内存、文件等），但有各自的栈和寄存器。
  • 开销：创建和切换线程的开销较小，因为线程共享进程的资源，上下文切换也相对简单。
  • 通信：线程之间的通信相对容易，因为它们共享相同的地址空间，可以通过共享变量进行通信。

2. 并发和并行的区别

并发（Concurrency）：

  • 定义：并发是指在同一个时间段内多个任务交替执行。并发不一定是同时执行，而是通过快速切换任务来实现。
  • 特点：并发的核心是任务的切换和协调。即使在单核 CPU 上也可以实现并发。
  • 示例：在一个单核 CPU 系统上，操作系统通过快速切换任务，使多个任务看起来是同时执行的。

并行（Parallelism）：

  • 定义：并行是指在同一时刻多个任务同时执行。并行需要多核 CPU 或多处理器系统支持。
  • 特点：并行的核心是任务的同时执行，是真正意义上的同时进行。
  • 示例：在一个四核 CPU 系统上，四个任务可以在同一时刻分别在四个不同的核上运行。

3. 多线程的优势与风险

多线程的优势：

  • 资源利用率高：多线程可以有效利用 CPU 资源，尤其在多核 CPU 上，可以实现真正的并行执行，提升程序的执行效率。
  • 响应速度快：多线程可以提高程序的响应速度，尤其在 I/O 密集型任务中，可以在等待 I/O 操作的同时执行其他任务，提高响应性。
  • 简化建模：多线程可以将复杂任务分解成多个线程，每个线程执行一个独立的子任务，使程序的结构更加清晰和易于维护。

多线程的风险：

  • 并发问题：多线程共享同一地址空间，容易产生并发问题，如竞态条件、死锁等。需要使用同步机制（如锁、条件变量）来避免这些问题。
  • 资源开销：虽然线程的创建和切换开销比进程小，但仍然存在一定的资源开销，特别是大量线程的情况下，线程调度和上下文切换会带来性能损耗。
  • 调试复杂：多线程程序的执行顺序是非确定性的，调试和排查问题比较复杂，难以重现问题。
  • 内存消耗：每个线程都有自己的栈空间，过多的线程会占用大量内存，可能导致内存不足的问题。

具体示例：

  • 并发问题：假设两个线程同时修改一个共享变量，如果没有正确同步，可能会导致数据不一致的问题。比如，一个银行系统中，两个线程同时进行转账操作，如果不加锁，就可能导致账户余额计算错误。
  • 死锁问题：两个线程相互等待对方释放锁，就会导致死锁。例如，线程 A 持有资源 1 的锁并等待资源 2 的锁，而线程 B 持有资源 2 的锁并等待资源 1 的锁，就会导致死锁。

线程的生命周期

在 Java 高级开发面试中，深入理解线程的不同状态及其状态转换的条件和触发机制是非常重要的。以下是对这些问题的详细回答：

线程的不同状态

Java 中的线程状态包括以下几种：

  1. NEW：新建状态
  2. RUNNABLE：可运行状态
  3. BLOCKED：阻塞状态
  4. WAITING：等待状态
  5. TIMED_WAITING：计时等待状态
  6. TERMINATED：终止状态

1. NEW（新建状态）

描述：线程对象已经创建，但尚未调用 start() 方法。

状态转换：

  • 调用 start() 方法后，线程进入 RUNNABLE 状态。

2. RUNNABLE（可运行状态）

描述：线程已经启动，正在运行或准备运行，但操作系统线程调度程序尚未将其选中。

状态转换：

  • 线程被操作系统调度并分配 CPU 时间后，实际开始执行线程的 run() 方法。
  • 当线程主动调用 Thread.yield() 或被操作系统中断时，可能会重新回到可运行状态。

3. BLOCKED（阻塞状态）

描述：线程被阻塞，等待进入 synchronized 代码块或方法，无法获得锁。

状态转换：

  • 线程获得锁后进入 RUNNABLE 状态。

4. WAITING（等待状态）

描述：线程等待另一线程的特定动作。它通过调用以下方法进入该状态：

  • Object.wait()，不带超时参数
  • Thread.join()，不带超时参数
  • LockSupport.park()

状态转换：

  • 其他线程调用 notify()、notifyAll() 或 Thread.interrupt()，等待线程重新获取 CPU 时间片后进入 RUNNABLE 状态。
  • 等待的线程完成了预期操作（例如 Thread.join() 等待的线程终止），当前线程重新进入 RUNNABLE 状态。

5. TIMED_WAITING（计时等待状态）

描述：线程在指定的时间内等待另一个线程的特定操作。它通过调用以下方法进入该状态：

  • Thread.sleep(long millis)
  • Object.wait(long timeout)
  • Thread.join(long millis)
  • LockSupport.parkNanos(long nanos)
  • LockSupport.parkUntil(long deadline)

状态转换：

  • 指定的时间到期后，线程进入 RUNNABLE 状态。
  • 其他线程调用 notify()、notifyAll() 或 Thread.interrupt()，计时等待线程重新获取 CPU 时间片后进入 RUNNABLE 状态。

6. TERMINATED（终止状态）

描述：线程执行完成或因异常退出 run() 方法。

状态转换：

  • 线程从 RUNNABLE 状态进入 TERMINATED 状态。

状态转换图

NEW
 |
 | start()
 v
RUNNABLE <------> BLOCKED
  | ^                 |
  | |                 |
  v |   sleep()       |
WAITING <------> TIMED_WAITING
  | ^                 |
  | | notify()        |
  v |
TERMINATED

触发机制

  • 调用 start() 方法：线程从 NEW 状态进入 RUNNABLE 状态。
  • 获取锁成功：线程从 BLOCKED 状态进入 RUNNABLE 状态。
  • 调用 wait() 方法：线程从 RUNNABLE 状态进入 WAITING 状态。
  • 调用 sleep(long millis) 方法：线程从 RUNNABLE 状态进入 TIMED_WAITING 状态。
  • 调用 notify() 或 notifyAll() 方法：线程从 WAITING 状态进入 RUNNABLE 状态。
  • 调用 interrupt() 方法：被中断的线程从 WAITING 或 TIMED_WAITING 状态进入 RUNNABLE 状态。
  • 运行完成：线程从 RUNNABLE 状态进入 TERMINATED 状态。

创建线程

创建线程的方式

在 Java 高级开发面试中，关于创建线程的方式，可以从以下几个方面进行回答，涵盖各自的优点和适用场景：

1. 继承 Thread 类

代码示例
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();
    }
}
解释
  • 优点：
    • 简单直接，适合快速创建并启动线程。
  • 缺点：
    • Java 不支持多继承，继承 Thread 类后无法再继承其他类。
    • 更推荐使用其他方法进行线程创建以实现解耦和可扩展性。

2. 实现 Runnable 接口

代码示例
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable is running");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}
解释
  • 优点：
    • 更适合面向对象编程，避免 Java 单继承的限制。
    • 可实现任务与线程的解耦，更灵活。
  • 缺点：
    • 没有直接返回值。

3. 实现 Callable 接口（结合 Future 使用）

代码示例
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());

        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
解释
  • 优点：
    • 可以返回结果或抛出异常。
    • 提供更多的灵活性和控制。
  • 缺点：
    • 比 Runnable 稍复杂。

4. 使用 Executor 框架

代码示例
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Runnable task1 = () -> System.out.println("Task 1 is running");
        Runnable task2 = () -> System.out.println("Task 2 is running");

        executor.execute(task1);
        executor.execute(task2);

        executor.shutdown();
    }
}
解释
  • 优点：
    • 提供了线程池管理，简化并发编程。
    • 更高效地利用系统资源，避免频繁创建和销毁线程的开销。
  • 缺点：
    • 需要理解并管理线程池的生命周期。

启动线程

在 Java 高级开发面试中，关于 Thread 类的 start() 方法与 run() 方法的区别，可以从以下几个方面进行详细回答：

1. start() 方法与 run() 方法的基本区别

start() 方法
  • start() 方法用于启动新线程。
  • 它会创建一个新的执行线程，并调用线程的 run() 方法。
  • start() 方法调用后，Thread 实例会进入 RUNNABLE 状态，等待 JVM 调度。
run() 方法
  • run() 方法是线程执行的入口点。
  • 如果直接调用 run() 方法，则不会启动新线程，它只是普通的方法调用，运行在当前调用线程中。

2. 代码示例

start() 方法示例
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(); // 启动新线程，调用 run() 方法
    }
}
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.run(); // 在当前线程中调用 run() 方法，不会启动新线程
    }
}

3. 详细解释

start() 方法的工作原理
  • 当调用 start() 方法时，Java 虚拟机 (JVM) 会启动一个新的线程，并调用该线程的 run() 方法。
  • 线程 start() 方法的调用顺序是这样的：start() -> JVM 调用 -> run()。
  • 新线程会运行在并行的执行路径上，与主线程分开。
run() 方法的工作原理
  • run() 方法是包含线程执行逻辑的普通方法。
  • 直接调用 run() 方法不会启动新线程，它会在当前线程中同步执行，就像调用普通方法一样。

5. 总结

  • start() 方法：启动新线程，线程会调用其 run() 方法执行任务，允许并发执行。
  • run() 方法：不启动新线程，仅作为普通方法在当前线程中运行。

面试回答模板

“在 Java 中，start() 方法和 run() 方法的主要区别在于：start() 方法用于启动新线程，并调用线程的 run() 方法，从而使代码在新的并行线程中执行；而直接调用 run() 方法不会启动新线程，它只是普通的方法调用，在当前线程中同步执行。使用 start() 方法可以实现并发执行，而 run() 方法则不能。”

线程管理

线程优先级

关于设置线程优先级及其效果和局限性的回答，可以从以下几个方面进行详细回答：

1. 设置线程优先级

Java 提供了 Thread 类的 setPriority(int newPriority) 方法，用于设置线程的优先级。线程的优先级范围在 Thread.MIN_PRIORITY (1) 到 Thread.MAX_PRIORITY (10) 之间，默认优先级是 Thread.NORM_PRIORITY (5)。

代码示例
public class ThreadPriorityExample {
    public static void main(String[] args) {
        Thread highPriorityThread = new Thread(() -> {
            System.out.println("High priority thread running");
        });
        highPriorityThread.setPriority(Thread.MAX_PRIORITY); // 设置最高优先级

        Thread lowPriorityThread = new Thread(() -> {
            System.out.println("Low priority thread running");
        });
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY); // 设置最低优先级

        lowPriorityThread.start();
        highPriorityThread.start();
    }
}

在这个示例中，highPriorityThread 被设置为最高优先级，而 lowPriorityThread 被设置为最低优先级。

2. 优先级调度的效果

线程优先级是一个提示，告知线程调度器哪些线程更重要，应该获得更多的 CPU 时间。调度器将尝试根据优先级来分配 CPU 资源，通常情况下，高优先级的线程会比低优先级的线程先执行或获得更多的 CPU 时间。

预期效果
  • 高优先级的线程通常会比低优先级的线程先被调度执行。
  • 在资源有限的情况下，高优先级的线程有更大机会获得 CPU 时间片。

3. 优先级调度的局限性

尽管设置了线程优先级，但在实际应用中，优先级调度的效果可能并不显著。这是因为 Java 的线程调度依赖于底层操作系统的线程调度机制，不同操作系统对线程优先级的支持和实现方式有所不同。

局限性
  • 平台依赖：线程优先级调度效果在不同操作系统上可能不一致。例如，在某些操作系统上，线程优先级可能会被忽略或效果不明显。
  • 公平性：高优先级线程可能会长时间占用 CPU 资源，导致低优先级线程无法及时执行，可能引发线程饥饿问题。
  • 实时性要求：对于高实时性要求的系统，单纯依赖线程优先级可能无法满足需求，需要使用其他调度策略或机制。

面试回答模板

“在 Java 中，可以通过 Thread#setPriority(int newPriority) 方法设置线程的优先级，范围是 1 到 10。线程优先级是一个提示，帮助线程调度器决定哪些线程应优先获得 CPU 时间。然而，线程优先级的效果依赖于底层操作系统，不同操作系统的实现可能有所不同。在某些平台上，线程优先级的效果可能并不明显。此外，高优先级线程可能会导致低优先级线程饥饿，因此在使用线程优先级时需要谨慎，结合具体应用场景和平台特性进行合理设置。”

守护线程

1. 守护线程的定义

守护线程（Daemon Thread）是一个在后台运行的线程，当 JVM 中!!#ff0000 没有!!任何非守护线程运行时，JVM 将会退出，无论!!#ff0000 是否有!!守护线程在运行。守护线程通常用于执行一些后台任务，如垃圾回收器等。

在 Java 中，可以通过调用 Thread 类的 setDaemon(true) 方法将一个线程设置为守护线程。该方法必须在线程启动之前调用，否则会抛出 IllegalThreadStateException 异常。

代码示例
public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("Daemon thread running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        daemonThread.setDaemon(true); // 设置为守护线程
        daemonThread.start();

        try {
            Thread.sleep(3000); // 主线程睡眠 3 秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread finished");
    }
}

在这个示例中，守护线程会一直运行，直到主线程结束。当主线程结束时，JVM 会停止所有的守护线程。

2. 使用场景

守护线程通常用于执行一些需要在后台运行的任务，这些任务通常不应该阻止 JVM 的退出。以下是一些常见的使用场景：

  • 后台服务：例如垃圾回收器、日志记录器、性能监控器等，这些服务需要在应用程序运行期间一直运行，但不应该阻止 JVM 退出。
  • 定时任务：一些需要定期运行的任务，例如定期清理缓存、发送心跳包等，可以使用守护线程来实现。
  • 资源管理：管理一些系统资源的分配和回收，如连接池、线程池等，可以通过守护线程来监控和管理。

3. 守护线程的注意事项

  • 必须在启动前设置：setDaemon(true) 方法必须在线程启动前调用，否则会抛出 IllegalThreadStateException 异常。
  • 不要依赖守护线程执行重要任务：由于 JVM 在没有非守护线程运行时会退出，因此不应该依赖守护线程执行重要的任务，这些任务可能会在未完成的情况下被终止。
  • 避免过度使用守护线程：虽然守护线程对于后台任务很有用，但过多的守护线程可能会影响应用程序的性能和可维护性。

面试回答模板

“守护线程（Daemon Thread）是一个在后台运行的线程，当 JVM 中没有任何非守护线程运行时，JVM 将会退出，无论是否有守护线程在运行。守护线程通常用于执行一些后台任务，如垃圾回收器、日志记录器、性能监控器等。在 Java 中，可以通过 Thread#setDaemon(true) 方法将一个线程设置为守护线程，但必须在线程启动之前调用。守护线程适用于一些不应该阻止 JVM 退出的任务，如后台服务、定时任务和资源管理。需要注意的是，守护线程不应该用于执行重要任务，因为 JVM 在没有非守护线程时会退出，导致守护线程未完成的任务被终止。”

线程同步

同步机制

1. synchronized 关键字的使用

synchronized 是 Java 中用来实现线程同步的关键字，它可以用于方法和代码块上，其作用是防止多个线程同时访问共享资源，保证线程安全。

同步方法

当一个方法被 synchronized 修饰时，它称为同步方法。同步方法会对整个方法体进行加锁，使得同一时间只能有一个线程执行该方法。其他线程需要等待当前线程执行完毕释放锁后才能执行该方法。

示例：

public class Counter {
    private int count;

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

    public synchronized int getCount() {
        return count;
    }
}

在上面的例子中，increment() 和 getCount() 方法都是同步方法，对 count 变量的读写操作是线程安全的。

同步代码块

除了同步方法外，还可以使用同步代码块来实现对临界资源的同步访问。使用同步代码块可以更加灵活地控制同步的范围，而不是对整个方法进行加锁。

示例：

public class Counter {
    private int count;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }

    public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

在这个例子中，同步代码块使用了 synchronized (this)，锁定了当前对象 this，确保了 increment() 和 getCount() 方法对 count 的访问是线程安全的。

2. 同步方法与同步代码块的区别

  • 锁的粒度：

    • 同步方法锁定的是整个方法体，因此锁的粒度较粗，可能会影响性能，尤其是方法体内部操作非常多时。
    • 同步代码块可以选择合适的对象作为锁，锁的粒度可以更细，可以只锁定代码块内部访问的临界资源，从而提高并发性能。

  • 锁定对象：

    • 同步方法使用的锁对象是当前对象实例（对于静态方法是类的 Class 对象）。
    • 同步代码块可以使用任意对象作为锁，通过 synchronized (obj) 的方式指定。

  • 灵活性：

    • 同步代码块相比同步方法更加灵活，可以在方法内部选择合适的位置进行同步，避免不必要的锁竞争，提升并发效率。

面试回答模板

关于 synchronized 的使用：

“synchronized 是 Java 中用来实现线程同步的关键字，它可以用于方法和代码块上。同步方法通过 synchronized 修饰整个方法，确保同一时间只有一个线程可以执行该方法，从而保证方法内部的操作是线程安全的。而同步代码块则可以在代码块内部指定锁对象，通过 synchronized (obj) 的方式来实现对临界资源的同步访问，提高了灵活性和并发性能。”

关于同步方法与同步代码块的区别：

“同步方法锁定的是整个方法体，因此锁的粒度较粗，可能会影响性能，特别是方法内部操作非常多时。而同步代码块可以选择合适的锁对象，锁的粒度可以更细，可以只锁定代码块内部访问的临界资源，从而提高并发性能。此外，同步方法使用的锁对象是当前对象实例（对于静态方法是类的 Class 对象），而同步代码块可以使用任意对象作为锁，提供了更大的灵活性。”

重入锁

1. java.util.concurrent.locks.Lock 接口及其实现

Lock 接口

Lock 接口是 Java 并发包中用于锁定的通用接口，它定义了一组用于获取锁和释放锁的方法，允许更灵活地控制多线程对共享资源的访问。

ReentrantLock

ReentrantLock 是 Lock 接口的一个实现类，支持可重入的锁定，意味着同一线程可以多次获得同一个锁，而不会发生死锁。它相比 synchronized 关键字提供了更多的操作和控制。

2. Lock 接口常用方法

lock()

lock() 方法用于获取锁。如果锁不可用，则当前线程会被阻塞，直到获取锁为止。

unlock()

unlock() 方法用于释放锁。必须在 lock() 方法之后、临界区代码执行结束之前调用，否则会导致其他线程无法获取锁。

tryLock()

tryLock() 方法尝试获取锁，如果锁可用，则立即返回 true 并获取锁；如果锁不可用，则立即返回 false，而不会阻塞当前线程。

示例
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final Lock lock = new ReentrantLock();

    public void performTask() {
        lock.lock(); // 获取锁
        try {
            // 临界区代码，需要保护的共享资源操作
            System.out.println("Thread " + Thread.currentThread().getName() + " is executing critical section.");
            Thread.sleep(1000); // 模拟执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        LockExample example = new LockExample();

        // 创建多个线程执行任务
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                example.performTask();
            });
            thread.start();
        }
    }
}

面试回答模板

关于 Lock 接口及 ReentrantLock 的回答：

“Lock 接口是 Java 并发包中用于锁定的通用接口，定义了 lock()、unlock() 和 tryLock() 等方法，提供了对多线程访问共享资源的精细控制。ReentrantLock 是 Lock 接口的一个实现类，支持可重入锁定，同一线程可以多次获取同一个锁，防止了死锁的发生。”

关于 lock()、unlock()、tryLock() 方法的使用：

“lock() 方法用于获取锁并阻塞当前线程直到获取成功，unlock() 方法用于释放锁，必须在临界区代码执行结束前调用。tryLock() 方法尝试获取锁，如果成功则返回 true，否则返回 false，不会阻塞当前线程。”

ReentrantReadWriteLock

ReentrantReadWriteLock 是 Java 并发包中的一个读写锁实现，允许多个线程在没有写入操作时同时访问共享资源，从而提高读取操作的并发性能。以下是关于 ReentrantReadWriteLock 的使用场景和方法的面试回答：

1. 使用场景

高读写比例的场景

在读操作远远多于写操作的情况下，使用 ReentrantReadWriteLock 可以提高并发效率。它允许多个线程同时获取读锁（共享锁），但只允许一个线程获取写锁（独占锁），保证写操作的原子性和线程安全性。

数据库连接池

在数据库连接池等资源池的实现中，通常对于读操作可以使用读锁，而对于写操作（如获取、释放连接）可以使用写锁，以提高并发处理能力。

缓存实现

对于缓存系统，读取数据时可以使用读锁，而更新或清除缓存时可以使用写锁，从而保证数据的一致性和线程安全性。

2. 方法和使用示例

方法
  • readLock()：返回一个读锁实例。
  • writeLock()：返回一个写锁实例。
  • readLock().lock()：获取读锁，允许多个线程同时获取。
  • writeLock().lock()：获取写锁，只允许一个线程获取，其他线程等待。
示例
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void readData() {
        lock.readLock().lock(); // 获取读锁
        try {
            // 读取数据的逻辑
            System.out.println("Reading data...");
            Thread.sleep(1000); // 模拟读取数据耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock(); // 释放读锁
        }
    }

    public void writeData() {
        lock.writeLock().lock(); // 获取写锁
        try {
            // 更新数据的逻辑
            System.out.println("Writing data...");
            Thread.sleep(1000); // 模拟更新数据耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock(); // 释放写锁
        }
    }

    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();

        // 多线程同时读取数据
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                example.readData();
            }).start();
        }

        // 多线程同时写入数据
        new Thread(() -> {
            example.writeData();
        }).start();
    }
}

面试回答模板

关于 ReentrantReadWriteLock 的回答：

“ReentrantReadWriteLock 是 Java 并发包中的读写锁实现，允许多个线程同时读取共享资源，但只允许一个线程写入。适用于读多写少的场景，可以显著提高读取操作的并发性能。”

关于 readLock() 和 writeLock() 方法的使用：

“readLock() 方法返回一个读锁实例，允许多个线程同时获取；writeLock() 方法返回一个写锁实例，只允许一个线程获取。通过这些方法，可以实现对共享资源的读写控制，保证数据的一致性和线程安全性。”

显示锁和隐式锁

  1. 显式锁（显示锁）：

    • 显式锁是通过显式地创建和管理锁对象来实现的，常见的实现包括 ReentrantLock、ReadWriteLock 的实现类等。
    • 使用显式锁时，需要显式地调用 lock() 方法获取锁，并在合适的时候调用 unlock() 方法释放锁。
    • 显式锁提供了更灵活的锁管理和线程调度控制，能够支持更复杂的锁定和解锁策略。

  2. 隐式锁（内置锁）：

    • 隐式锁是Java语言内置的锁机制，使用 synchronized 关键字来实现锁定和解锁。
    • 当使用 synchronized 关键字修饰方法或代码块时，会隐式地使用对象的内置锁来进行同步，无需显式地创建锁对象。
    • 隐式锁简单易用，适合大多数同步需求，可以避免显式锁可能带来的复杂性和风险。
使用场景

  1. 显式锁的使用场景：

    • 需要实现更复杂的锁策略，如超时锁、可中断锁等。
    • 需要在锁定期间执行一些特定的操作，如条件等待。
    • 需要更细粒度的锁控制，如读写锁。

    示例场景：

    • 实现一个多线程并发控制的缓存系统，需要精确控制缓存项的读取和更新。
    • 实现数据库连接池，需要控制连接的获取和释放。

  2. 隐式锁的使用场景：

    • 对于简单的同步需求，如单个方法或代码块的同步。
    • 对象的一些基本操作需要同步控制，如对共享变量的读写操作。

    示例场景：

    • 多个线程访问共享资源（如计数器、列表）时，通过 synchronized 关键字确保线程安全。
    • 实现一个简单的生产者-消费者模型，使用 wait() 和 notify() 方法实现线程间的协作。

面试回答模板

关于显示锁和隐式锁的区别：

“显式锁（如 ReentrantLock）是通过显式地创建和管理锁对象来实现的，提供了更灵活的锁管理和线程调度控制；而隐式锁（如 synchronized 关键字）则是通过Java语言内置的锁机制来实现，简化了锁的使用。”

关于使用场景的回答：

“在需要实现复杂的锁策略或精确的线程调度控制时，使用显式锁更为合适；而对于简单的同步需求和基本的共享资源保护时，隐式锁则更为简便和直观。”

window_ye
关注
专栏目录
Java高手的30k之路｜面试宝典｜精通多线程（二）
weixin_41379244的博客
06-18 719
线程间通信｜wait/notify/notifyAll｜Condition接口｜await/siginal/signalAll｜两者区别｜线程调度与执行｜Executor框架｜Fork-join框架｜ForkJoinPool｜RecursiveTask ｜RecursiveAction｜工作窃取算法｜并行计算负载均衡策略
Java高手的30k之路｜面试宝典｜精通多线程（四）- 并发编程
weixin_41379244的博客
06-19 1145
死锁｜活锁｜线程Dump｜线程饥饿｜原子变量｜自旋锁｜CAS｜内存屏障｜JMM｜volatile｜指令重排序｜happens-before｜编发编程优化
Java高手的30k之路｜面试宝典｜精通Map篇
weixin_41379244的博客
06-14 1739
Map｜HashMap | LinkedHashMap | TreeMap | ConcurrentHashMap | CAS | Unsafe
Java高手的30k之路｜面试宝典｜精通多线程（三）- 并发编程
weixin_41379244的博客
06-18 665
Executors类的工厂方法｜池技术｜ThreadPoolExecutor配置｜ThreadLocal｜ Future和FutureTask｜CompletableFuture｜CountDownLatch CyclicBarrier Semaphore BlockingQueue Exchanger Phaser
Java高手的30k之路｜面试宝典｜精通JVM
weixin_41379244的博客
06-19 791
堆内存结构｜垃圾回收器｜新生代｜老年代｜元空间｜垃圾回收算法｜垃圾回收调优参数｜
Java高手的30k之路｜面试宝典｜精通Netty
weixin_41379244的博客
06-23 1035
Netty｜核心组件｜零拷贝｜ByteBuf｜内存管理｜高性能序列化｜线程模型｜EventLoop ｜WorkerThread｜异常捕获｜自定义组件
Java高手的30k之路｜面试宝典｜精通网络编程
weixin_41379244的博客
06-22 1395
OSI｜TCP/IP｜IPv4 IPv6 端口｜NIO AIO | TCP UDP | 三次握手｜四次挥手｜
Java高手的30k之路｜面试宝典｜精通数据库
weixin_41379244的博客
07-01 620
ACID ｜ full join | cross join | group by & having | 窗口函数 ｜数据库设计规范化和反规范化｜缓存｜分区｜分库分表｜事务｜分布式事务｜两阶段提交
Java高手的30k之路｜面试宝典｜精通跳表SkipList
weixin_41379244的博客
06-15 879
SkipList ｜代码实现｜每一层节点选择的随机算法｜新增/删除/查询｜跳表的应用场景
互联网大厂JAVA岗面试宝典
02-08
《互联网大厂JAVA岗面试宝典》是一本旨在帮助求职者成功通过互联网大厂JAVA岗位面试的指南。这本书涵盖了从初步筛选、技术面试、管理层面试到人力资源面试的全过程，不仅包含JAVA技术要点，还提供了丰富的面试策略和...
java面试宝典2-3.docx
01-11
- 多线程编程 - 泛型和反射 - I/O操作 4. **框架与工具**： - Spring框架 - Hibernate持久化框架 - Maven构建工具 - Git版本控制系统 5. **软技能**： - 问题解决能力 - 沟通与团队合作 - 学习新技能的...
Java年薪30W+面试必问知识之《2020年面试宝典总纲》
Java_supermanNO1的博客
10-22 1076
前言 一份月薪30K的java开发岗位工作要求是怎样的呢？面试都会问到哪些呢？ 任职要求： 1、计算机或相关专业本科（或以上）学历，具备3年以上Java服务端开发经验，熟悉常用的Java开源框架，如熟悉Spring、SpringMVC、SpringBoot、Hibernate、MyBatis等，了解其原理和实现机制； 2、擅长Java Web服务开发，熟悉掌握各种Web应用开发模式，具有丰富的高并发、大数据系统的设计、研发、调试经验者优先； 3、精通Java及面向对象设计开发，熟悉常见设计模式，有系统设计
987页的Java面试宝典，看完才发现，应届生求职也没那么难
didi558的博客
04-23 1514
②面试技术攻克篇 Java基础知识 Java Web 数据库原理 设计模式 数据结构与算法 海量数据处理 SSM企业级应用（Spring+SpringMVC+Mybatis） SpringBoot+SpringCloud 需要完整版Java面试宝典的朋友，只需要关注我后[戳这里，暗号：CSDN](()即可。 [](()一、面试经验技巧篇 =================================================================
服务器虚拟化
最新发布
Hellc007的博客
10-30 378
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 949
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 436
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Java Web开发教程：从入门到精通
孤客科技
10-25 1086
Java Web开发是一个充满挑战和机遇的领域。通过本文的学习，您应已掌握Java Web开发的基础知识和实践技巧。不断实践、深入学习，将使您在这个领域越走越远。希望您能在未来的开发旅程中创造出更多精彩的Web应用！如有任何问题或想法，欢迎在评论区留言讨论！期待您的参与与分享！
Java复习24（PTA)
2301_79272475的博客
10-30 227
Java复习24（PTA)：多种排序的book类*
Java学习Day54：初遇萍萍(权限控制)
weixin_51721783的博客
10-29 685
web.xml：在health_backend工程的web.xml文件中配置用于整合Spring Security框架的过滤器DelegatingFilterProxy。
Java多线程面试宝典：经典题与解答解析
本文档主要围绕多线程编程在Java面试中的经典问题进行深入探讨，涉及到了Java中实现线程的不同方式、多线程同步机制、Runnable与Thread类的选择、`notify`与`notifyAll`的区别、`wait`/`notify`/`notifyAll`方法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值