当前位置：首页 > Java

Java线程如何通讯

2026-03-03 13:33:58Java

Java线程通讯的方法

Java线程通讯主要通过共享内存和消息传递两种方式实现。以下是常见的线程通讯方法：

共享变量

使用共享变量是最基础的线程通讯方式。多个线程可以访问同一个对象的成员变量或静态变量。

public class SharedVariableExample {
    private static boolean flag = false;

    public static void main(String[] args) {
        new Thread(() -> {
            while (!flag) {
                // 等待flag变为true
            }
            System.out.println("Flag is now true");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("Flag set to true");
        }).start();
    }
}

wait()/notify()/notifyAll()

这些是Object类的方法，必须在同步块或同步方法中使用。

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

    public void doWait() throws InterruptedException {
        synchronized (lock) {
            System.out.println("Waiting...");
            lock.wait();
            System.out.println("Resumed");
        }
    }

    public void doNotify() {
        synchronized (lock) {
            System.out.println("Notifying...");
            lock.notify();
        }
    }
}

BlockingQueue

BlockingQueue接口提供了线程安全的队列实现，支持阻塞操作。

public class BlockingQueueExample {
    private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

    public void producer() throws InterruptedException {
        queue.put("Message");
    }

    public void consumer() throws InterruptedException {
        String message = queue.take();
    }
}

CountDownLatch

允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3);

    public void worker() {
        // 工作代码
        latch.countDown();
    }

    public void await() throws InterruptedException {
        latch.await();
        System.out.println("All workers completed");
    }
}

CyclicBarrier

允许一组线程互相等待，直到到达某个公共屏障点。

public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(3);

    public void worker() throws BrokenBarrierException, InterruptedException {
        // 工作代码
        barrier.await();
    }
}

Semaphore

控制同时访问特定资源的线程数量。

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

    public void accessResource() throws InterruptedException {
        semaphore.acquire();
        try {
            // 访问资源
        } finally {
            semaphore.release();
        }
    }
}

Exchanger

允许两个线程在集合点交换对象。

public class ExchangerExample {
    private final Exchanger<String> exchanger = new Exchanger<>();

    public void threadA() throws InterruptedException {
        String received = exchanger.exchange("Data from A");
    }

    public void threadB() throws InterruptedException {
        String received = exchanger.exchange("Data from B");
    }
}

PipedInputStream/PipedOutputStream

提供线程间的管道通讯。

public class PipedStreamExample {
    private final PipedInputStream in = new PipedInputStream();
    private final PipedOutputStream out = new PipedOutputStream();

    public PipedStreamExample() throws IOException {
        in.connect(out);
    }

    public void writer() throws IOException {
        out.write("Hello".getBytes());
    }

    public void reader() throws IOException {
        byte[] buffer = new byte[1024];
        int len = in.read(buffer);
        String message = new String(buffer, 0, len);
    }
}

选择哪种线程通讯方式取决于具体应用场景。共享变量适合简单场景，wait/notify适合条件等待，BlockingQueue适合生产者消费者模式，CountDownLatch适合一次性等待，CyclicBarrier适合可重用屏障，Semaphore适合资源池管理，Exchanger适合双向交换，管道流适合字节流通讯。

Java线程如何通讯