Java详解多线程协作作业之信号同步

在多线程协作时，信号同步是一种重要的协作机制。它可以让线程等待某个条件满足后再继续执行，从而实现线程之间的协作。本篇文章将详细讲解Java中信号同步的用法和原理。

使用等待/通知机制实现信号同步

Java中使用等待/通知机制来实现信号同步。该机制由以下三个方法实现：

1. wait()：使线程等待，直到其他线程调用了notify()或notifyAll()方法。
2. notify()：唤醒一个在等待该对象的线程。
3. notifyAll()：唤醒所有在等待该对象的线程。

等待/通知机制需要与synchronized关键字一起使用。在使用等待/通知机制时，线程必须获得对象的锁才能调用wait()、notify()或notifyAll()方法。

下面是一个使用等待/通知机制实现信号同步的示例：

public class SignalSynTest {
    private boolean hasDataToProcess = false;

    public synchronized void produce() {
        // 生产数据，设置标志位为true
        hasDataToProcess = true;
        System.out.println("Producing data...");
        // 通知等待该对象锁的线程
        notify();
    }

    public synchronized void consume() throws InterruptedException {
        while(!hasDataToProcess) {
            // 等待该对象锁的通知
            wait();
        }
        // 处理数据
        System.out.println("Consuming data...");
        // 设置标志位为false
        hasDataToProcess = false;
    }

    public static void main(String[] args) throws InterruptedException {
        SignalSynTest synTest = new SignalSynTest();

        // 启动一个生产者线程
        new Thread(() -> {
            while(true) {
                synTest.produce();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 启动一个消费者线程
        new Thread(() -> {
            while(true) {
                try {
                    synTest.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

在以上示例中，生产者线程和消费者线程共享了一个SignalSynTest对象。生产者线程通过调用produce()方法来生产数据并设置标志位为true，然后通知等待该对象锁的线程；消费者线程通过调用consume()方法来等待对象锁的通知，一旦收到通知，立即处理数据并将标志位设置为false。

使用Lock和Condition接口实现信号同步

Java中还可以使用java.util.concurrent包中的Lock和Condition接口来实现信号同步。Lock和synchronized类似，都可以获得一个对象的锁。但是，相比synchronized而言，Lock接口提供了更多的灵活性。

下面是一个使用Lock和Condition接口实现信号同步的示例：

public class SignalSynTest2 {
    private boolean hasDataToProcess = false;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void produce() {
        lock.lock();
        try {
            // 生产数据，设置标志位为true
            hasDataToProcess = true;
            System.out.println("Producing data...");
            // 通知等待该条件的线程
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    public void consume() throws InterruptedException {
        lock.lock();
        try {
            while (!hasDataToProcess) {
                // 等待该条件的通知
                condition.await();
            }
            // 处理数据
            System.out.println("Consuming data...");
            // 设置标志位为false
            hasDataToProcess = false;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SignalSynTest2 synTest = new SignalSynTest2();

        // 启动一个生产者线程
        new Thread(() -> {
            while(true) {
                synTest.produce();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        // 启动一个消费者线程
        new Thread(() -> {
            while(true) {
                try {
                    synTest.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

在以上示例中，生产者线程和消费者线程共享了一个SignalSynTest2对象。生产者线程通过调用produce()方法来生产数据并设置标志位为true，然后通知等待该条件的线程；消费者线程通过调用consume()方法来等待等待该条件的通知，一旦收到通知，立即处理数据并将标志位设置为false。当使用Lock和Condition接口实现信号同步时，线程需要先获得锁，然后再调用await()、signal()或signalAll()方法。在处理完数据之后，线程需要释放锁，以供其他线程使用。

示例说明

在以上示例中，我们定义了两个示例，分别使用了等待/通知机制和Lock和Condition接口来实现信号同步。这两个示例都包含了一个生产者线程和一个消费者线程，生产者线程负责生产数据并通知消费者线程，消费者线程负责处理数据并等待生产者线程的通知。通过这两个示例，我们可以了解到Java中信号同步的两种不同实现方式，并掌握信号同步的基本原理和使用方法。