多线程基础：线程通信内容补充

多线程基础：线程通信内容补充

---

---

前言

前文内容中讲了线程通信的内容，但是不够完善，所以这边文章是针对那部分的内容的一个补充说明。

在Java中，线程之间的通信主要有几种方式，包括使用共享变量、wait()/notify()/notifyAll()方法、join()方法、Lock和Condition接口，以及并发集合和原子变量等。

---

一、wait(), notify(), notifyAll()

这些方法属于Object类，用于在同步块或同步方法中实现线程间的通信。

1. wait(): 使当前线程等待，直到其他线程调用此对象的notify()或notifyAll()方法。
2. notify(): 唤醒在此对象监视器上等待的单个线程。
3. notifyAll(): 唤醒在此对象监视器上等待的所有线程。

public class WaitNotifyExample {  
    private static final Object lock = new Object();  
    private static boolean ready = false;  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(() -> {  
            synchronized (lock) {  
                while (!ready) {  
                    try {  
                        lock.wait();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
                System.out.println("Thread 1 is running");  
            }  
        });  
  
        Thread t2 = new Thread(() -> {  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            synchronized (lock) {  
                ready = true;  
                lock.notifyAll();  
            }  
        });  
  
        t1.start();  
        t2.start();  
    }  
}

在这个例子中，线程1先获取到lock锁，然后开始循环，在第一次循环就调用了wait()方法，使线程进入等待状态，也就释放了锁，cpu时间片切到线程2，线程2获取到锁之后，讲ready设置为true同时唤醒其他所有线程，线程1进行运行状态，重新进行遍历判断，此时判断内容为false，所以线程1执行结束。

二、join()

join()方法是Thread类的一个方法，它使当前执行线程等待，直到调用join()方法的线程执行完毕。

public class JoinExample {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(() -> {  
            for (int i = 0; i < 5; i++) {  
                System.out.println("Thread 1: " + i);  
                try {  
                    Thread.sleep(500);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  
  
        t1.start();  
        t1.join(); // 等待t1线程执行完毕  
  
        for (int i = 0; i < 5; i++) {  
            System.out.println("Main thread: " + i);  
        }  
    }  
}

在这个例子中，主线程会等待线程t1执行完毕后再继续执行。

三、Lock 和 Condition

Lock接口及其实现（如ReentrantLock）以及Condition接口提供了比synchronized和wait()/notify()更灵活和强大的线程同步机制。

import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
public class LockConditionExample {  
    private final Lock lock = new ReentrantLock();  
    private final Condition condition = lock.newCondition();  
    private boolean ready = false;  
  
    public void waitForSignal() throws InterruptedException {  
        lock.lock();  
        try {  
            while (!ready) {  
                condition.await(); // 等待信号  
            }  
            System.out.println("Received signal");  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public void signal() {  
        lock.lock();  
        try {  
            ready = true;  
            condition.signalAll(); // 发送信号  
        } finally {  
            lock.unlock();  
        }  
    }  
  
    public static void main(String[] args) throws InterruptedException {  
        LockConditionExample example = new LockConditionExample();  
        Thread t1 = new Thread(example::waitForSignal);  
        t1.start();  
  
        Thread.sleep(1000); // 让t1先开始执行并等待  
        example.signal(); // 发送信号给t1  
    }  
}

在这个例子中，waitForSignal方法中的线程会等待signal方法发送信号。

四、并发集合和原子变量

1、并发集合

Java的java.util.concurrent包提供了许多线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。这些集合内部实现了必要的同步机制，使得多个线程可以安全地并发访问它们。

import java.util.concurrent.ConcurrentHashMap;  
  
public class ConcurrentHashMapExample {  
    private static final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(() -> {  
            map.put("key1", 1);  
            System.out.println("Thread 1 put key1: " + map.get("key1"));  
        });  
  
        Thread t2 = new Thread(() -> {  
            map.put("key2", 2);  
            System.out.println("Thread 2 put key2: " + map.get("key2"));  
        });  
  
        t1.start();  
        t2.start();  
    }  
}

在这个例子中，两个线程可以并发地向ConcurrentHashMap中添加元素，而无需添加额外的同步锁。

2、原子变量

原子变量类（如AtomicInteger、AtomicLong、AtomicBoolean等）提供了在并发编程中原子地更新变量的方法。原子操作是不可中断的，即在多线程环境下，当一个线程在执行原子操作时，其他线程无法访问该变量，从而保证了线程安全。

import java.util.concurrent.atomic.AtomicInteger;  
  
public class AtomicIntegerExample {  
    private static final AtomicInteger counter = new AtomicInteger(0);  
  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(() -> {  
            for (int i = 0; i < 5; i++) {  
                counter.incrementAndGet(); // 原子地增加计数器的值  
                System.out.println("Thread 1 counter: " + counter.get());  
            }  
        });  
  
        Thread t2 = new Thread(() -> {  
            for (int i = 0; i < 5; i++) {  
                counter.incrementAndGet(); // 原子地增加计数器的值  
                System.out.println("Thread 2 counter: " + counter.get());  
            }  
        });  
  
        t1.start();  
        t2.start();  
  
        t1.join();  
        t2.join();  
  
        System.out.println("Final counter value: " + counter.get());  
    }  
}

在这个例子中，两个线程都尝试原子地增加同一个AtomicInteger的值，无需额外的同步。

---

总结

1. wait()/notify()/notifyAll()是基于对象监视器的传统线程通信方式，需要配合synchronized关键字使用。
2. join()用于让一个线程等待另一个线程完成其执行。
3. Lock和Condition提供了更灵活和强大的线程同步机制，能够更精细地控制线程间的通信和协作。
4. 并发集合和原子变量简化了多线程编程中的同步问题，使得开发者能够更轻松地编写线程安全的代码。

在选择使用哪种线程通信方式时，需要根据具体的场景和需求来决定。例如，对于简单的等待/通知场景，wait()/notify()可能足够；对于需要更精细控制的场景，Lock和Condition可能更合适；而对于只需要原子更新变量的场景，原子变量类则是最简单的选择。