做网站的宽和高有限制吗seminar

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

---

---

前言

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

在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可能更合适；而对于只需要原子更新变量的场景，原子变量类则是最简单的选择。