Java多线程并发编程：锁和同步问题实例分析

原创忘是亡心i 2024-11-14 16:48 141阅读 0赞

在Java多线程编程中，锁（Lock）和同步（Synchronization）是两个重要的概念，用于控制多个线程对共享资源的访问。

1. 锁（Lock）
- `java.util.concurrent.locks.Lock`是抽象类，提供了基本的锁操作。
- `ReentrantLock`是一个具体的实现，它继承了`Lock`抽象类，并添加了一些额外的功能，如可中断锁定、公平性等。

2. 同步（Synchronization）
- `java.lang.Object`中的`wait()`, `notify()`, 和 `notifyAll()`方法用于线程间的同步。
- `synchronized`关键字可以应用于代码块，用于锁定对象的特定部分，确保同一时刻只有一个线程访问该部分。

实例分析：
```java
import java.util.concurrent.locks.ReentrantLock;

public class LockAndSyncExample {

private final Object object = new Object();
    private final ReentrantLock lock = new ReentrantLock();

public void thread1() {
        lock.lock(); // 获取锁
        try {
            if (checkCondition()) { // 确定条件满足
                synchronized (object) { // 对对象进行同步，确保同一时刻只有一个线程访问该部分
                    doSomeTask();
                }
            } else { // 条件不满足
                System.out.println("Thread 1: Skipping due to condition not met.");
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

public void thread2() {
        lock.lock(); // 获取锁
        try {
            if (checkCondition()) { // 确定条件满足
                System.out.println("Thread 2: Starting task...");
                synchronized (object) { // 对对象进行同步，确保同一时刻只有一个线程访问该部分
                    doSomeOtherTask();
                }
            } else { // 条件不满足
                System.out.println("Thread 2: Skipping due to condition not met.");
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

private boolean checkCondition() {
        // 实际的条件检查，这里只是示例
        return (new Random()).nextInt(3) == 0;
    }

private void doSomeTask() {
        System.out.println("Thread 1: Doing some task...");
    }

private void doSomeOtherTask() {
        System.out.println("Thread 2: Starting a different task...");
    }
}
```
在这个例子中，`thread1` 和 `thread2` 分别执行不同的任务。两个任务都对一个共享对象（`object`）进行了同步。

通过锁（如使用`ReentrantLock`），当一个线程获取了对象的锁后，其他试图同一时刻获取该锁的线程将被阻塞，直到获得锁的线程释放锁。

这样就可以避免多个线程同时修改共享资源导致数据不一致的问题。