Java并发编程：锁与信号量的对比及实例

原创迈不过友情╰ 2024-12-13 19:33 7阅读 0赞

在Java中，锁（Lock）和信号量（Semaphore）都是用于实现线程同步的工具。下面是它们的一些对比：

1. **控制粒度**：
   - 锁：可以对单个资源进行锁定，例如文件或者数据库连接。
   - 信号量：通常用于限制同时访问同一组资源的线程数量。

2. **操作方式**：
   - 锁：获取锁是阻塞的（block），释放锁是非阻塞的（non-blocking）。
   - 信号量：增加计数器值通常是非阻塞的，减少或等于0则需要阻塞直到计数值大于0。

实例对比：

1. **文件锁定**：
```java
import java.io.File;
import java.io.IOException;

public class FileLockExample {
    private static final Object lock = new Object();

public static void main(String[] args) {
        Thread thread1 = new Thread(() -> lockFile("file1.txt")), "Thread 1");
        Thread thread2 = new Thread(() -> lockFile("file2.txt")), "Thread 2");

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

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private static void lockFile(String fileName) {
        File file = new File(fileName);
        synchronized (lock) {
            try {
                if (!file.exists()) {
                    throw new IOException("File does not exist: " + fileName);
                }
                // 逻辑处理，比如操作文件
                System.out.println("Locked " + fileName);
            } catch (IOException e) {
                e.printStackTrace();
                // 文件锁定失败时，通常需要释放锁
                synchronized (lock) {
                    lock.notifyAll(); // 唤醒等待锁的线程
                    System.out.println("Unlocking " + fileName);
                }
            }
        }
    }
}
```
2. **信号量**：
```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1); // 初始化信号量，允许的最大线程数为1

public static void main(String[] args) {
        Thread thread1 = new Thread(() -> acquireSemaphore(semaphore)), "Thread 1");
        Thread thread2 = new Thread(() -> acquireSemaphore(semaphore)), "Thread 2");

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

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private static void acquireSemaphore(Semaphore semaphore) {
        synchronized (semaphore) {
            if (!semaphore.tryAcquire()) { // 如果信号量已满，尝试获取会阻塞
                System.out.println("Waiting for semaphore..."); // 线程等待通知
                try {
                    // 等待其他线程释放信号量
                    semaphore.wait(); // 调用wait()方法，使当前线程进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

System.out.println("Semaphore acquired!"); // 信号量已获取，通知线程继续执行
    }
}
```
总结：
锁（Lock）和信号量（Semaphore）都是用于实现线程同步的工具。锁更适合于对单个资源进行锁定，而信号量则更适用于控制同时访问特定资源的线程数量。