Java多线程同步工具Lock和Semaphore实战示例

原创 Dear 丶 2024-10-05 17:06 57阅读 0赞

在Java中，Lock和Semaphore是常用的线程同步工具。以下将分别提供这两种工具的实战示例。

1. Lock（锁）：
   - Lock提供了更细粒度的同步。
   - 使用方式：`ReentrantLock lock = new ReentrantLock();`

示例：
   ```java
   class Counter {
       private int count;
       private final Lock lock = new ReentrantLock();

public void increment() {
           lock.lock();
           try {
               count++;
           } finally {
               lock.unlock();
           }
       }

public int decrement() {
           lock.lock();
           try {
               if (count > 0) {
                   count--;
               }
           } finally {
               lock.unlock();
           }
           return count;
       }

public int getCount() {
           lock.lock();
           try {
               return count;
           } finally {
               lock.unlock();
           }
       }
   }

class CounterThread extends Thread {
       private final Counter counter;

CounterThread(Counter counter) {
           this.counter = counter;
       }

@Override
       public void run() {
           for (int i = 0; i < 10; i++) {
               counter.increment();
               try {
                   // 省略其他耗时操作
                   Thread.sleep(50);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   }

public class LockDemo {
       public static void main(String[] args) {
           Counter counter = new Counter();

CounterThread thread1 = new CounterThread(counter);
           CounterThread thread2 = new CounterThread(counter);

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

// 等待所有线程执行完毕
           try {
               thread1.join();
               thread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
   ```
   
   这个示例中，`Counter`类使用了Lock进行同步。两个线程（thread1和thread2）分别对计数器进行递增操作。

2. Semaphore（信号量）：
   - Semaphore用于控制同时访问资源的线程数量。
   - 使用方式：`Semaphore semaphore = new Semaphore(5); // 创建一个允许5个并发执行的信号量`

示例：
   ```java
   class CounterWithSemaphore {
       private int count;
       private final Semaphore semaphore = new Semaphore(3);

public void increment() throws InterruptedException {
           semaphore.acquire();
           try {
               count++;
           } finally {
               semaphore.release();
           }
       }

public int decrement() throws InterruptedException {
           semaphore.acquire();
           try {
               if (count > 0) {
                   count--;
               }
           } finally {
               semaphore.release();
           }
           return count;
       }

public int getCount() {
           return count;
       }
   }

class CounterSemaphoreThread extends Thread {
       private final CounterWithSemaphore counter;

CounterSemaphoreThread(CounterWithSemaphore counter) {
           this.counter = counter;
       }

@Override
       public void run() {
           for (int i = 0; i < 10; i++) {
               try {
                   counter.increment();
                   // 省略其他耗时操作
                   Thread.sleep(50);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               try {
                   counter.decrement();
                   // 省略其他耗时操作
                   Thread.sleep(50);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   }

public class SemaphoreDemo {
       public static void main(String[] args) {
           CounterWithSemaphore counter = new CounterWithSemaphore();

CounterSemaphoreThread thread1 = new CounterSemaphoreThread(counter);
           CounterSemaphoreThread thread2 = new CounterSemaphoreThread(counter);

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

// 等待所有线程执行完毕
           try {
               thread1.join();
               thread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
   ```

这个示例中，`CounterWithSemaphore`类使用了信号量进行同步。每个线程（thread1和thread2）分别对计数器进行递增操作。

3. 总结：
   - Lock用于更细粒度的锁管理，适用于需要精确控制并发访问的场景。
   - Semaphore则是一种轻量级的锁机制，它允许一定数量的并发执行线程，并在到达预设的最大并发限制后阻止新的线程进入。