多线程同步：让你的Java程序井井有条

2022-11-26 16:41:32

多线程同步：让你的 Java 程序井然有序

在现代计算世界中，多线程编程已成为程序员必备的技能。它可以极大地提高程序的效率和性能，但是也带来了一个新的挑战：如何确保当多个线程同时访问共享资源时不会产生冲突？如何避免死锁和数据竞争等问题？

这就是多线程同步发挥作用的地方。多线程同步是一种机制，可协调多个线程对共享资源的访问，确保数据的完整性和一致性。在 Java 中，有各种各样的多线程同步机制可供使用，每种机制都有其独特的优点和缺点。

1. 临界区

临界区是指代码中的一段，其中包含对共享资源的访问。为了防止多个线程同时访问同一临界区，需要使用某种同步机制来保护它。最简单的方法是使用 synchronized 。

public class Counter {
    private int count;

    public synchronized void increment() {
        count++;
    }
}

在上面的代码中，increment() 方法被 synchronized 关键字修饰，这意味着在任何给定时间只有一个线程可以执行该方法。这确保了 count 变量不会被多个线程同时修改，从而避免了数据竞争。

2. 互斥锁

互斥锁是一种更高级的同步机制，它允许线程在进入临界区之前获取锁。如果锁已被另一个线程持有，当前线程将被阻塞，直到锁被释放。

public class Counter {
    private int count;
    private final Lock lock = new ReentrantLock();

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

在上面的代码中，increment() 方法使用 lock.lock() 和 lock.unlock() 来获取和释放锁。这确保了 count 变量只能被一个线程同时修改。

3. 条件变量

条件变量是一种用于线程间通信的同步机制。它允许线程在满足特定条件时被唤醒。

public class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final Condition notEmpty = queue.newCondition();
    private final Condition notFull = queue.newCondition();

    public void produce() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == queue.getMaxSize()) {
                    notEmpty.await();
                }
                queue.add(1);
                notFull.signal();
            }
        }
    }

    public void consume() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    notFull.await();
                }
                queue.remove();
                notEmpty.signal();
            }
        }
    }
}

在上面的代码中，ProducerConsumer 类使用两个条件变量（notEmpty 和 notFull）来实现生产者和消费者之间的通信。当队列为空时，消费者将被阻塞，直到生产者生产一个元素。当队列已满时，生产者将被阻塞，直到消费者消费一个元素。

4. 线程通信

线程通信是指线程之间交换信息或数据。在 Java 中，有各种线程通信方式，包括 wait()、notify() 和 notifyAll() 方法、管道、信号量等。

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 is notified");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                lock.notify();
                System.out.println("Thread 2 notifies Thread 1");
            }
        });

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