Java并发编程中Lock、Synchronized的区别示例

原创川长思鸟来 2024-09-24 01:42 90阅读 0赞

在Java并发编程中，`Lock`接口和`synchronized`关键字都是用来实现线程同步的工具。但是两者在使用上有一定的区别：

1. 语法差异：
   - `synchronized`：直接修饰对象或代码块。
   ```java
   // 对象锁定
   synchronized (object) {
       // 代码块
   }
   ```

- `Lock`：从`java.util.concurrent.locks.LockSupport`继承，提供更细粒度的控制。
   ```java
   // 锁实例
   Lock lock = ...;
   
   try (lock.lock()) {
       // 代码块
   }
   ```
2. 入侵性：
   - `synchronized`：会将锁对象作为方法参数，对调用者可见。对于多线程编程来说，这可能会导致“饥饿”问题（即一个线程等待资源，而其他线程已经拥有资源）。
   ```java
   // 示例，可能导致饥饿问题
   class Resource {
       private int count;
       
       public Resource(int count) {
           this.count = count;
       }
       
       public synchronized void acquire() {
           if (count == 0) {
               throw new IllegalStateException("No resource available");
           }
           count--;
       }
       
       public synchronized void release() {
           count++;
       }
   }

// 线程1
   Thread thread1 = new Thread(() -> {
       Resource resource = new Resource(2);
       
       try (resource.acquire()) {
           // 使用资源的代码
           System.out.println("Thread 1 acquired the resource");
       } catch (Exception e) {
           e.printStackTrace();
       }
       
       try (resource.release()) {
           System.out.println("Thread 1 released the resource");
       }
   }));
   
   // 线程2
   Thread thread2 = new Thread(() -> {
       Resource resource = new Resource(2);
       
       try (resource.acquire()) {
           System.out.println("Thread 2 acquired the resource");
           // 使用资源的代码
       } catch (Exception e) {
           e.printStackTrace();
       }
       
       try (resource.release()) {
           System.out.println("Thread 2 released the resource");
       }
   }));

thread1.start();
   thread2.start();
   ```

3. 控制粒度：
   - `synchronized`：基于对象的锁，提供了粗粒度的同步控制。
   - `Lock`：提供更细粒度的控制，如可重复读、独占锁定等。

总的来说，在需要进行精确线程同步的时候，建议使用`Lock`接口。同时在设计并发代码时，要尽量避免全局锁（即单例模式）的使用。