实战挑战：Java并发编程中锁与信号量的应用示例

原创 àì夳堔傛蜴生んèń 2024-10-17 12:48 53阅读 0赞

在Java的并发编程中，锁和信号量是两种常用的同步工具。下面分别以这两种工具为例，给出应用示例。

1. 锁（Synchronized）

```java
// 假设我们有一个共享资源类Resource
public class Resource {
    private int count = 0;

// 同步方法，当count小于5时，进入等待状态
    public synchronized void increaseCount() {
        if (count < 5) {
            count++;
            System.out.println("Waiting for count < 5... Current Count: " + count);
            // 当count等于5时，唤醒等待的线程
            notifyAll();
        } else {
            System.out.println("Count is already >= 5. No increase needed.");
        }
    }

// 测试用例，多线程并发增加资源
    public static void main(String[] args) {
        Resource resource = new Resource();

new Thread(() -> {
            while (!resource.count >= 5) {
                try {
                    resource.increaseCount();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Count >= 5 reached, exiting thread.");
        })).start();

// 创建另一个线程，模拟资源被耗尽
        new Thread(() -> {
            while (resource.count < 10) {
                try {
                    resource.increaseCount();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Resource exhaustion reached, exiting thread.");
        })).start();

// 等待资源耗尽
        try {
            Thread.sleep(6000); // 模拟耗时操作，使资源耗尽
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Main thread finished after resource exhaustion.");
    }
}
```

这个示例展示了如何在Java并发编程中使用锁来同步对共享资源的操作。当资源达到一定数量（如5）时，操作会进入等待状态，直到唤醒。

2. 信号量（Semaphore）

信号量是一种比锁更细粒度的同步工具，它管理一个有限的资源池，每个线程可以请求并占用一个资源。

```java
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

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

public void acquireSemaphore() throws InterruptedException {
        // 当资源数量大于0时，尝试获取资源
        semaphore.acquire();
        System.out.println("Acquired semaphore for count = " + semaphore.getCount());
    }

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

CountDownLatch latch = new CountDownLatch(3);

// 创建并初始化3个线程
        Thread t1 = new Thread(() -> {
            try {
                while (!latch.countDown())) {
                    example.acquireSemaphore();
                }
                System.out.println("Thread 1 completed after down count");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

Thread t2 = new Thread(() -> {
            try {
                while (!latch.countDown())) {
                    example.acquireSemaphore();
                }
                System.out.println("Thread 2 completed after down count");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

Thread t3 = new Thread(() -> {
            try {
                while (!latch.countDown())) {
                    example.acquireSemaphore();
                }
                System.out.println("Thread 3 completed after down count");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

// 启动线程
        t1.start();
        t2.start();
        t3.start();

// 等待所有线程完成
        latch.countDown();

System.out.println("All threads completed. Main thread finishing.");
    }
}
```

这个示例展示了如何使用信号量来同步对共享资源的操作。当资源数量达到预设值（如5）时，操作会进入等待状态，直到有其他线程释放了资源，这些线程就可以获取并使用资源了。

注意：在实际应用中，你可能需要根据具体的业务需求来选择合适的同步工具。