java中如何实现线程间同步

在Java中，线程间同步可以通过使用synchronized关键字、使用Lock接口与Condition接口、使用Semaphore类、使用CountDownLatch类和CyclicBarrier类实现。这些方法都是Java提供的线程同步机制，能够确保多线程之间的同步和协作，避免出现线程安全问题。

一、使用SYNCHRONIZED关键字

synchronized是Java中最基本的同步机制。当一个线程访问一个对象的synchronized方法或synchronized代码块时，它会自动获得该对象的锁。其他试图访问该对象的线程将被阻塞，直到首个线程释放该对象的锁。

举个例子，假设有一个银行账户类BankAccount，我们想确保在任何时候只有一个线程可以对账户进行取款操作，可以使用synchronized关键字来保护取款方法：

public class BankAccount {
    private double balance;
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }
}

在这个例子中，当一个线程正在执行withdraw方法时，其他试图访问该方法的线程将被阻塞，直到该方法执行完毕。这样可以确保在任何时刻，只有一个线程可以更改账户余额。

二、使用LOCK接口与CONDITION接口

Lock接口提供了比synchronized关键字更强大的线程同步机制。与synchronized不同，Lock接口允许线程在尝试获取锁时等待一定的时间，或者在等待锁的时候响应中断。Condition接口是与Lock接口配套使用的，它提供了一种线程间协调的机制。

下面是一个使用Lock和Condition的例子，该例子实现了一个有界队列，当队列满时，生产者线程会等待；当队列空时，消费者线程会等待：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class BoundedQueue<T> {
    private Object[] items;
    private int addIndex, removeIndex, count;
    private Lock lock = new ReentrantLock();
    private Condition notEmpty = lock.newCondition();
    private Condition notFull = lock.newCondition();
    public BoundedQueue(int size) {
        items = new Object[size];
    }
    public void add(T t) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();
            }
            items[addIndex] = t;
            if (++addIndex == items.length) {
                addIndex = 0;
            }
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    public T remove() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            Object x = items[removeIndex];
            if (++removeIndex == items.length) {
                removeIndex = 0;
            }
            --count;
            notFull.signal();
            return (T) x;
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，生产者线程和消费者线程可以同时访问BoundedQueue对象，但是他们的操作是同步的，当队列满时，生产者线程会等待；当队列空时，消费者线程会等待。

三、使用SEMAPHORE类

Semaphore类是Java提供的一个线程同步工具类，它可以控制同时访问某个特定资源的线程数量，通过acquire()获取一个许可，如果无许可则会被阻塞，通过release()释放一个许可。这是一种较为复杂的线程同步机制，适用于更为复杂的多线程环境。

以下是一个使用Semaphore实现的连接池：

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class ConnectionPool {
    private Semaphore semaphore;
    private boolean[] used;
    public ConnectionPool(int size) {
        semaphore = new Semaphore(size, true);
        used = new boolean[size];
        for (int i = 0; i < size; i++) {
            used[i] = false;
        }
    }
    public void useConnection() {
        try {
            semaphore.acquire();
            int index = findAvailableConnection();
            if (index != -1) {
                used[index] = true;
                System.out.println("Thread " + Thread.currentThread().getName() + " is using connection " + index);
                TimeUnit.SECONDS.sleep(2);
                used[index] = false;
            }
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private synchronized int findAvailableConnection() {
        for (int i = 0; i < used.length; i++) {
            if (!used[i]) {
                return i;
            }
        }
        return -1;
    }
}

在这个例子中，Semaphore用来限制同时使用连接的线程数量，当所有的连接都被使用时，新的线程会被阻塞，直到有线程释放连接。

四、使用COUNTDOWNLATCH类和CYCLICBARRIER类

CountDownLatch和CyclicBarrier是Java提供的两种线程同步工具类，它们可以用来控制线程之间的依赖关系。

CountDownLatch允许一个或多个线程等待其他线程完成操作。它的构造函数接收一个int类型的参数，这个参数表示线程需要等待的操作数量。每当一个操作完成，CountDownLatch的countDown()方法就会被调用，这会使得计数器的值减一。当计数器的值变为0时，所有等待的线程都会被唤醒。

CyclicBarrier则是让一组线程达到一个同步点后再一起继续执行。它的构造函数接收一个int类型的参数，这个参数表示同步点的线程数量。当一个线程达到同步点，它会调用CyclicBarrier的await()方法，这会使得线程阻塞，直到所有的线程都达到同步点，所有线程才会一起继续执行。

以下是一个使用CountDownLatch的例子，该例子模拟了一个并行计算的场景，主线程等待所有的计算线程完成计算后，才继续执行：

import java.util.concurrent.CountDownLatch;
public class ParallelComputation {
    private CountDownLatch latch;
    public ParallelComputation(int threadCount) {
        latch = new CountDownLatch(threadCount);
    }
    public void compute(Runnable task) {
        new Thread(() -> {
            task.run();
            latch.countDown();
        }).start();
    }
    public void await() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，主线程调用compute方法启动计算线程，然后调用await方法等待所有的计算线程完成计算。

总结

Java提供了多种线程同步机制，包括synchronized关键字、Lock接口与Condition接口、Semaphore类、CountDownLatch类和CyclicBarrier类。这些机制可以用来控制多线程之间的同步和协作，确保程序的正确性和效率。在实际开发中，应根据具体情况选择合适的线程同步机制。

java中如何实现线程间同步

相关问答FAQs：