面试官:线程间有几种通信方式?

在Java中，有几种常见的线程间通信方式：

共享内存：在Java中，可以使用共享变量来实现线程之间的共享内存通信。多个线程可以访问和修改相同的共享变量。为了保证线程安全，可以使用关键字 synchronized 或 volatile 来保证变量的可见性或互斥访问。

public class SharedMemoryExample {
    private int sharedVariable;

    public synchronized void setSharedVariable(int value) {
        this.sharedVariable = value;
    }

    public synchronized int getSharedVariable() {
        return this.sharedVariable;
    }
}

Wait/Notify机制：通过 wait() 和 notify() 方法，线程可以实现等待和唤醒的机制实现线程间通信。

public class WaitNotifyExample {
    private boolean ready = false;

    public synchronized void waitForSignal() throws InterruptedException {
        while (!ready) {
            wait();
        }
        // 执行相应操作
    }

    public synchronized void signal() {
        ready = true;
        notify();
    }
}

Condition条件变量：Java中的 Condition 接口提供了类似于 wait() 和 notify() 的功能，可以用于线程间的等待和唤醒操作。

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

public class ConditionVariableExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean ready = false;

    public void waitForSignal() throws InterruptedException {
        lock.lock();
        try {
            while (!ready) {
                condition.await();
            }
            // 执行相应操作
        } finally {
            lock.unlock();
        }
    }

    public void signal() {
        lock.lock();
        try {
            ready = true;
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

BlockingQueue阻塞队列：Java中的 BlockingQueue 实现了线程安全的队列，并提供了阻塞操作。线程可以通过 put() 方法插入元素，并在队列满时阻塞，或者使用 take() 方法取出元素，在队列为空时阻塞。

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

public class BlockingQueueExample {
    private BlockingQueue queue = new LinkedBlockingQueue<>();

    public void producer(int value) throws InterruptedException {
        queue.put(value);
    }

    public void consumer() throws InterruptedException {
        int value = queue.take();
        // 处理元素的操作
    }
}

信号量：通过使用Java中的Semaphore、CountDownLatch、CyclicBarrier等类来实现线程间同步和通信。信号量是一种线程间通信的方式，用于控制同时访问某个资源或临界区的线程数量。下面是一个基于信号量的线程间通信的例子：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
  	// 信号量的初始计数为1
    private Semaphore semaphore = new Semaphore(1); 

    public void accessResource() {
        try {
            semaphore.acquire(); // 获取信号量，计数减1
            // 访问共享资源的操作
            // ...
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release(); // 释放信号量，计数加1
        }
    }
}

在上面的示例中，Semaphore 的初始计数为1，表示只允许一个线程同时访问共享资源。在 accessResource() 方法中，线程首先调用 acquire() 方法获取信号量，如果当前计数值为0，则线程会被阻塞，等待其他线程释放信号量。当线程执行完共享资源的操作后，调用 release() 方法释放信号量，计数值加1，其他等待的线程可以继续执行。

通过信号量，可以控制同时访问共享资源的线程数量，有效地进行线程间的协调和同步。在实际应用中，可以根据具体情况，设置不同的初始计数值，以满足不同的需求。

这些都是Java中常用的几种线程间通信方式，可以根据具体的场景和需求选择适合的方式来实现线程间的通信。

网站首页 > 文章精选正文

猜你喜欢

网站首页 > 文章精选 正文

面试官:线程间有几种通信方式?

猜你喜欢

网站首页 > 文章精选正文