如何在Java中创建线程通信的四种方式你知道吗

当多个线程共同操作同一个对象时，可能会遇到竞争态况或阻塞，需要使用线程通信来实现协调和同步，以确保程序的正确性和效率。在Java中，创建线程通信的方式有以下四种：

一、wait()和notify()

wait()和notify()是Java中最基本的线程通信方式。wait()的作用是使当前线程挂起，直到另一个线程调用相同对象的notify()方法唤醒它。notify()的作用是唤醒在该对象上等待的一个线程。

以下是一个示例代码，说明wait()和notify()的使用方法：

class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() throws InterruptedException {
        synchronized (lock) {
            while (count >= 10) {
                lock.wait();
            }
            count++;
            lock.notifyAll();
        }
    }

    public void decrement() throws InterruptedException {
        synchronized (lock) {
            while (count <= 0) {
                lock.wait();
            }
            count--;
            lock.notifyAll();
        }
    }
}

在这个例子中，Counter类有一个count属性，它被两个并发的线程incrementThread和decrementThread访问。increment()方法用来增加count，而decrement()方法用来减少count。当count超过10或低于0时，线程会被挂起，直到另一线程唤醒它。

二、Condition

Java的Condition接口提供了一个更高级的线程通信机制，在一些复杂的并发编程场景中应用广泛。Condition接口由Lock接口提供，它支持多个等待队列和多种通知方式。

以下是一个使用Condition的示例代码：

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

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (count >= 10) {
                condition.await();
            }
            count++;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (count <= 0) {
                condition.await();
            }
            count--;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，我们使用ReentrantLock和Condition实现了与前面示例中的wait()和notify()方法相同的功能。

三、Semaphore

Semaphore（信号量）是一种更为灵活的并发控制机制，它允许多个线程同时访问临界区。Semaphore维护一个信号量计数器，当该计数器的值等于0时，任何尝试获取信号量的线程都会被阻塞。Semaphore提供了acquire()和release()方法用来获取或释放信号量。

以下是一个示例代码，说明Semaphore的使用方法：

import java.util.concurrent.Semaphore;

class Counter {
    private int count = 0;
    private Semaphore semaphore = new Semaphore(1);

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

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

在这个例子中，我们使用Semaphore来控制count变量的原子性访问。Semaphore的构造方法指定了信号量计数器的初始值，这个值代表了同时可以访问临界区的线程数量。

四、BlockingQueue

BlockingQueue是Java中用来实现“生产者-消费者”模型的重要工具。它是一个阻塞式队列，提供了wait()和notify()的等待-通知机制，可以实现生产者消费者模型的线程交互。

以下是一个示例代码，说明BlockingQueue的使用方法：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class Counter {
    private int count = 0;
    private BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(10);

    public void increment() throws InterruptedException {
        if (queue.size() >= 10) {
            synchronized (queue) {
                queue.wait();
            }
        }
        count++;
        queue.put(count);
    }

    public void decrement() throws InterruptedException {
        if (queue.size() <= 0) {
            synchronized (queue) {
                queue.wait();
            }
        }
        queue.take();
        count--;
        synchronized (queue) {
            queue.notify();
        }
    }
}

在这个例子中，我们使用BlockingQueue和wait()/notify()来实现线程通信。由于BlockingQueue是阻塞的，它可以等待队列非满或非空的事件。当队列已满或已空时，线程进入阻塞状态，只有在队列状态发生变化时才能被唤醒。这使得使用BlockingQueue实现生产者-消费者模型变得非常容易。

总之，在Java中创建线程通信的方式有很多种，以上就是其中常见的四种方式。在使用这些方式时，要特别注意线程安全和可靠性，以确保程序正确性和效率。