Java多线程编程：同步块与锁问题实例

原创清疚 2024-11-28 06:30 19阅读 0赞

在Java多线程编程中，同步块和锁是控制并发访问的关键工具。以下是一些实例来说明这些问题：

1. **同步块（Synchronized Block）**：
   ```java
   class Counter {
       private int count = 0;

synchronized void increment() {
           count++;
           notifyAll(); // 唤醒等待的线程
       }

public int getCount() {
           return count;
       }
   }

// 线程1，增加计数器
   Thread thread1 = new Thread(() -> {
       Counter counter = new Counter();
       while (true) { // 永远循环以保持线程活跃
           if (counter.increment()) {
               System.out.println("Counter incremented by " + counter.getCount());
               break; // 当计数器增加成功后，跳出循环
           } else {
               try {
                   Thread.sleep(100); // 休眠100毫秒以模拟耗时操作
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
       counter = null; // 清理计数器引用，减少内存泄露风险
     });

// 线程2，尝试获取未增加的计数器值
   Thread thread2 = new Thread(() -> {
       Counter counter = new Counter();
       while (true) { // 永远循环以保持线程活跃
           int count = counter.getCount(); // 获取当前计数器值
           if (count == 0) { // 如果计数器值为0，尝试增加计数器
               if (counter.increment()) {
                   System.out.println("Counter incremented by " + count);
                   break; // 当计数器增加成功后，跳出循环
               }
           } else {
               try {
                   Thread.sleep(100); // 休眠100毫秒以模拟耗时操作
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
       counter = null; // 清理计数器引用，减少内存泄露风险
     });
   ```
2. **锁（Lock）**：
   Java的`synchronized`关键字是基于锁实现同步。而`java.util.concurrent.locks.Lock`接口提供了更高级的锁功能。

例如：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class LockExample {
    private final Lock lock = new ReentrantLock(); // 使用ReentrantLock，它是可重入的

public void methodA() throws InterruptedException {
        lock.lock(); // 获取锁
        try {
            System.out.println("Method A executing ...");
            Thread.sleep(2000); // 模拟耗时操作
        } finally {
            lock.unlock(); // 释放锁
        }
    }

public void methodB() {
        lock.lock();
        try {
            System.out.println("Method B executing ...");
        } finally {
            lock.unlock();
        }
    }
}
```
在上述例子中，`methodA()`和`methodB()`都会尝试获取锁。如果获取成功，它们会执行自己的逻辑，最后通过`finally`块释放锁。

总结：Java多线程编程中的同步块（synchronized）是基于对象的锁定机制，而锁（Lock）提供了更高级别的控制，如可重入性等。