当前位置：首页 > article >正文

【后端面试总结】线程间通信的方法、特点与实现

article 2025/1/23 2:01:14

线程间通信是多线程编程中的核心概念，它允许多个线程在执行任务时相互协作，共享数据，从而实现复杂的并发控制。本文将详细介绍线程间通信的几种常见方法、各自的特点以及具体的实现方式。

1. 共享内存

方法介绍：
共享内存是线程间通信最直接、高效的方式。由于所有线程共享同一个进程的地址空间，因此可以直接通过读写共享变量来交换数据。

特点：

高效：数据访问速度快，因为不需要数据复制。
复杂：需要处理同步问题，防止数据竞争和不一致。

实现方式：

使用volatile关键字：确保变量对所有线程的可见性，但不保证原子性。
使用synchronized关键字：对代码块或方法进行同步，确保同一时刻只有一个线程可以执行。

public class SharedData {
    private volatile int data;

    public synchronized void setData(int value) {
        data = value;
    }

    public synchronized int getData() {
        return data;
    }
}

2. 消息传递

方法介绍：
线程间通过消息队列、管道等方式传递数据和信息，实现显式通信。

特点：

解耦：线程之间不需要直接访问共享内存，降低了耦合度。
灵活：可以支持多种消息格式和传递方式。

实现方式：

使用wait/notify机制：通过对象的wait()和notify()方法实现线程的等待和唤醒。
使用Java的BlockingQueue：线程安全的队列，支持阻塞操作。

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

public class ProducerConsumer {
    private BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

    public void produce(int value) throws InterruptedException {
        queue.put(value);
        System.out.println("Produced: " + value);
    }

    public void consume() throws InterruptedException {
        int value = queue.take();
        System.out.println("Consumed: " + value);
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    pc.produce(i);
                    Thread.sleep(100); // 模拟生产耗时
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                while (true) {
                    pc.consume();
                    Thread.sleep(150); // 模拟消费耗时
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

3. 互斥锁（Mutex）

方法介绍：
互斥锁用于保护共享资源，确保同一时刻只有一个线程可以访问该资源。

特点：

简单：实现方式简单，易于理解。
易死锁：不当使用可能导致死锁问题。

实现方式：

使用pthread库：在C/C++编程中，可以使用pthread库提供的互斥锁函数。
使用Java的ReentrantLock：Java中的可重入锁，支持公平锁和非公平锁。

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

public class MutexExample {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

    public void increment() {
        lock.lock();
        try {
            counter++;
            System.out.println(Thread.currentThread().getName() + " incremented counter to " + counter);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        MutexExample example = new MutexExample();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                example.increment();
            }
        }, "Thread-1");

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                example.increment();
            }
        }, "Thread-2");

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

4. 条件变量（Condition Variable）

方法介绍：
条件变量与互斥锁配合使用，允许线程在特定条件不满足时等待，并在条件满足时被唤醒。

特点：

高效：适用于需要等待某个条件成立的场景。
易误用：需要正确管理等待和通知，避免虚假唤醒和死锁。

实现方式：

使用pthread库：在C/C++编程中，可以结合互斥锁使用pthread_cond_wait和pthread_cond_signal函数。
使用Java的Condition接口：与Lock接口配合使用，提供await和signal方法。

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

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

    public void awaitReady() throws InterruptedException {
        lock.lock();
        try {
            while (!ready) {
                condition.await();
            }
            System.out.println("Thread is ready to proceed.");
        } finally {
            lock.unlock();
        }
    }

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

    public static void main(String[] args) {
        ConditionExample example = new ConditionExample();

        Thread thread1 = new Thread(() -> {
            try {
                example.awaitReady();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Thread-1");

        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(1000); // 模拟一些延迟
                example.signalReady();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Thread-2");

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