Java多线程同步问题：锁、信号量等使用

原创红太狼 2024-12-01 18:30 27阅读 0赞

在Java中，多线程的同步主要是通过两种机制实现的：锁（Lock）和信号量（Semaphore）。

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;
        }
        throw new IllegalStateException("Counter underflow");
    }

// Getter
    public synchronized int getCount() {
        return count;
    }
}
```
2. 信号量：
- `Semaphore`类：它类似于锁，但可以控制同时访问资源的线程数。例如：
```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(1);

public void criticalSection() {
        semaphore.acquire(); // 请求信号量
        try {
            // 执行临界区操作
            System.out.println("Critical Section executing...");
        } finally {
            // 无论是否执行临界区操作，都需要释放信号量
            semaphore.release();
        }
    }

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

new Thread(() -> {
            try {
                example.criticalSection(); // 进入临界区
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        })).start();

try {
            // 主线程在此等待进入临界区的线程执行完毕
            example.criticalSection(); // 重复尝试进入临界区，但因为已经被其他线程占用，所以会阻塞直到前面的线程释放。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
以上就是Java中使用锁（synchronized关键字）和信号量（Semaphore类）进行多线程同步的基本方式。