java锁面试

Java锁面试实现流程

流程图

flowchart TD
    A(开始)
    B(创建ReentrantLock对象)
    C(创建线程池ExecutorService对象)
    D(创建实现Runnable接口的任务对象)
    E(提交任务给线程池)
    F(线程池执行任务)
    G(获取锁)
    H(执行任务)
    I(释放锁)
    J(任务执行完毕)
    K(关闭线程池)
    L(结束)
    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    H --> I
    I --> J
    J --> K
    K --> L

类图

classDiagram
    class JavaLockInterview {
        -ReentrantLock lock
        -ExecutorService executorService
        -Task task
        +JavaLockInterview()
        +createLock()
        +createThreadPool()
        +createTask()
        +submitTask()
        +executeTask()
        +acquireLock()
        +performTask()
        +releaseLock()
        +taskCompleted()
        +terminateThreadPool()
    }
    class ReentrantLock {
        +lock()
        +unlock()
    }
    class ExecutorService {
        +submit(Runnable task)
        +shutdown()
    }
    class Task {
        +run()
    }
    JavaLockInterview "1" --> "1" ReentrantLock
    JavaLockInterview "1" --> "1" ExecutorService
    JavaLockInterview "1" --> "1" Task

代码实现步骤

步骤	描述	代码
1	创建ReentrantLock对象	ReentrantLock lock = new ReentrantLock();
2	创建线程池ExecutorService对象	ExecutorService executorService = Executors.newFixedThreadPool(5);
3	创建实现Runnable接口的任务对象	```java

class Task implements Runnable { public void run() { // 任务逻辑代码 } }

| 4 | 提交任务给线程池 | `executorService.submit(task);` |
| 5 | 线程池执行任务 | 由线程池自动调度执行任务 |
| 6 | 获取锁 | `lock.lock();` |
| 7 | 执行任务 | 执行任务逻辑代码 |
| 8 | 释放锁 | `lock.unlock();` |
| 9 | 任务执行完毕 | 任务执行完毕后执行下一步 |
| 10 | 关闭线程池 | `executorService.shutdown();` |
| 11 | 结束 | 程序执行结束 |

## 完整代码实现

```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class JavaLockInterview {
    private ReentrantLock lock;
    private ExecutorService executorService;
    private Task task;

    public JavaLockInterview() {
        createLock();
        createThreadPool();
        createTask();
        submitTask();
        executeTask();
    }

    private void createLock() {
        lock = new ReentrantLock();
    }

    private void createThreadPool() {
        executorService = Executors.newFixedThreadPool(5);
    }

    private void createTask() {
        task = new Task();
    }

    private void submitTask() {
        executorService.submit(task);
    }

    private void executeTask() {
        acquireLock();
        performTask();
        releaseLock();
    }

    private void acquireLock() {
        lock.lock();
    }

    private void performTask() {
        // 任务逻辑代码
    }

    private void releaseLock() {
        lock.unlock();
    }

    private void taskCompleted() {
        // 任务执行完毕后的操作
    }

    private void terminateThreadPool() {
        executorService.shutdown();
    }

    public static void main(String[] args) {
        JavaLockInterview interview = new JavaLockInterview();
        interview.taskCompleted();
        interview.terminateThreadPool();
    }

    private class Task implements Runnable {
        public void run() {
            // 任务逻辑代码
        }
    }
}

以上代码演示了如何使用Java锁实现一个面试场景，首先创建ReentrantLock对象作为锁，然后创建线程池ExecutorService对象用于执行任务。接着创建实现Runnable接口的任务对象，并提交给线程池。线程池会自动调度执行任务，任务中通过获取锁、执行任务逻辑和释放锁来保证线程安全。任务执行完毕后可以进行一些后续操作，如打印结果、记录日志等。最后关闭线程池，结束程序的执行