2024年10月19日虾皮购物一面已挂

以下是整理后的 Markdown 格式内容，优化了标题层级、列表嵌套和代码块显示，提升可读性：

1. Java中的锁机制 - 可重入锁

锁机制

同步方法和同步块
Lock接口

可重入锁（Reentrant Lock）

定义：允许同一线程多次获取同一把锁，避免递归调用或多层方法调用时的死锁问题。

特点：

重入性
公平性策略
手动锁管理

示例代码：

import java.util.concurrent.locks.ReentrantLock;

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

    public void methodA() {
        lock.lock(); // 获取锁
        try {
            System.out.println("In method A");
            methodB(); // 同一线程可重入调用
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public void methodB() {
        lock.lock(); // 再次获取锁
        try {
            System.out.println("In method B");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        new ReentrantLockExample().methodA();
    }
}

总结：可重入锁通过计数器实现重入逻辑，适用于递归调用、复杂同步场景，需注意手动释放锁以避免资源泄漏。

2. 可重入锁的使用场景

递归调用

import java.util.concurrent.locks.ReentrantLock;

public class RecursiveLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int counter = 0;

    public void increment() {
        lock.lock();
        try {
            counter++;
            System.out.println("Counter: " + counter);
            if (counter < 5) increment(); // 递归调用
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        new RecursiveLockExample().increment();
    }
}

多线程资源共享

import java.util.concurrent.locks.ReentrantLock;

public class SharedResource {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try { count++; }
        finally { lock.unlock(); }
    }

    // 省略getCount和多线程测试代码
}

复杂对象状态管理

public class ComplexObject {
    private final ReentrantLock lock = new ReentrantLock();
    private String state = "";

    public void updateState(String newState) {
        lock.lock();
        try {
            state = newState;
            processState(); // 同一线程内调用其他方法
        } finally { lock.unlock(); }
    }

    private void processState() { /* 处理状态 */ }
}

保证顺序执行

public class SequentialExecution {
    private final ReentrantLock lock = new ReentrantLock();
    private boolean initialized = false;

    public void performTask() {
        lock.lock();
        try {
            if (!initialized) initialize(); // 确保先初始化
            // 执行任务
        } finally { lock.unlock(); }
    }
}

总结：可重入锁在递归、资源竞争、状态管理和顺序控制场景中能有效避免死锁，提升并发安全性。

3. 讲一下AQS（AbstractQueuedSynchronizer）

AQS的基本概念

核心结构：

AQS的主要方法

方法名	作用描述
`tryAcquire(int arg)`	尝试获取独占锁，成功返回`true`
`tryRelease(int arg)`	尝试释放独占锁，成功返回`true`
`acquire(int arg)`	阻塞获取锁，调用`tryAcquire`失败则入队
`release(int arg)`	释放锁，调用`tryRelease`成功则唤醒后继节点
`getState()`/`setState()`	获取/设置同步状态

AQS的实现示例（独占锁）

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class MyLock {
    private static class Sync extends AbstractQueuedSynchronizer {
        // 尝试获取锁（CAS操作）
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) { // 状态0→1表示获取锁
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 尝试释放锁
        protected boolean tryRelease(int arg) {
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        // 判断当前线程是否持有锁
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
    }

    private final Sync sync = new Sync();

    public void lock() { sync.acquire(1); }
    public void unlock() { sync.release(1); }
}