Java并发编程中的锁对象和同步块案例解析

原创偏执的太偏执、 2024-09-20 19:24 57阅读 0赞

在Java并发编程中，锁（Lock）是实现线程同步的工具。而同步块则是使用锁进行代码控制的一种结构。

1. 锁对象：
- `synchronized`关键字：它定义一个同步方法或者同步代码块，它们会获取当前对象的锁。
```java
public class Counter {
    private int count;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalArgumentException("Counter is already zero.");
        }
    }

// getters and setters
}
```
- `ReentrantLock`类：Java提供了一个更高级别的锁，它提供了更多的功能，如公平性、可中断等待等。
```java
import java.util.concurrent.locks.ReentrantLock;

public class FairCounter {
    private int count;
    private ReentrantLock lock = new ReentrantLock();

public void increment() {
        lock.acquire();
        try {
            if (count > 0) {
                count++;
            } else {
                throw new IllegalArgumentException("Counter is already zero.");
            }
        } finally {
            lock.release();
        }
    }

// getters and setters
}
```
2. 同步块：
同步块通常是在`synchronized`关键字后面定义的，它会基于锁对象进行代码控制。

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

public void increment() {
        synchronized (this) {  // 使用当前对象作为锁对象
            if (count > 0) {
                count++;
            } else {
                throw new IllegalArgumentException("Counter is already zero.");
            }
        }
    }

// getters and setters
}
```
以上就是Java并发编程中锁对象和同步块的案例解析。