常见线程同步的方法及案例

线程同步是确保多个线程在访问共享资源时不会出现竞争条件的一种方法。本文主要是讲解一些常见的线程同步方法及其编写对应的代码，以下是一些常见的线程同步方法：

1. 互斥锁（Mutex）互斥锁是一种同步原语，用于防止同时多个线程同时访问一个共享资源。当一个线程获得锁后，其他试图获取该锁的线程将被阻塞，直到第一个线程释放它为止。
2. 信号量（Semaphore）信号量是一个非负整数或者二进制值，用于多线程编程中的同步和互斥。它可以控制对公共资源的访问次数，当没有可用资源时，请求资源的线程会被阻塞。
3. 条件变量（Condition Variable）条件变量通常与互斥锁一起使用，以允许线程在特定条件下等待并阻塞。当条件满足时，线程可以被唤醒并继续执行。

这些线程同步方法在不同的场景中有不同的适用性。在选择合适的同步策略时，需要考虑性能、可扩展性和易用性等因素。

1.互斥锁（Mutex）

互斥锁是一种同步原语，用于防止同时多个线程同时访问一个共享资源。当一个线程获得锁后，其他试图获取该锁的线程将被阻塞，直到第一个线程释放它为止。

在 Java 中，可以使用 ReentrantLock 类实现互斥锁。以下是一个简单的示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MutexExample {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

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

    public int getCounter() {
        return counter;
    }
}

2.信号量（Semaphore）

信号量是一个非负整数或者二进制值，用于多线程编程中的同步和互斥。它可以控制对公共资源的访问次数，当没有可用资源时，请求资源的线程会被阻塞。

在 Java 中，可以使用 Semaphore 类实现信号量。以下是一个简单的示例：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3);
    private int counter = 0;

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

    public int getCounter() {
        return counter;
    }
}

3.条件变量（Condition Variable）

条件变量通常与互斥锁一起使用，以允许线程在特定条件下等待并阻塞。当条件满足时，线程可以被唤醒并继续执行。

在 Java 中，可以使用 ReentrantLock 类和 Condition 接口实现条件变量。以下是一个简单的示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionVariableExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean available = false;

    public void await() throws InterruptedException {
        lock.lock();
        try {
            while (!available) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        lock.lock();
        try {
            available = true;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

这些线程同步方法在不同的场景中有不同的适用性。在选择合适的同步策略时，需要考虑性能、可扩展性和易用性等因素。