Java多线程锁机制问题解析

原创柔光的暖阳◎ 2024-09-22 05:33 53阅读 0赞

在Java中，多线程的锁机制主要包括synchronized关键字、Lock接口和ReentrantLock类等。

1. **synchronized关键字：**是最基本的同步机制，使用对象来锁定代码段。例如：

```java
public class Counter {
    private int count = 0;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalStateException("Cannot decrement count to negative");
        }
    }

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

2. **Lock接口和ReentrantLock类：**是Java并发包中的高级锁，提供了更细粒度的锁定、解锁以及获取锁状态等功能。

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

public void acquireExclusiveLock() {
        try {
            lock.acquireExclusive();
            System.out.println("Exclusive lock acquired");
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt(); // 强制中断
        }
    }

public void releaseExclusiveLock() {
        try {
            lock.releaseExclusive();
            System.out.println("Exclusive lock released");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

// 获取锁
        example.lock.acquire();

// 多线程执行操作
        Thread thread1 = new Thread(() -> example.acquireExclusiveLock()));
        Thread thread2 = new Thread(() -> example.releaseExclusiveLock()));

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程结束
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Example completed");
    }
}
```

以上是Java多线程锁机制的基本解析，根据实际需求和场景可能会有不同的使用策略。