使用wait和notify

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.Queue;
  5. public class ThreadDemo {
  6.     public static void main(String[] args) throws InterruptedException {
  7.         var q = new TaskQueue();
  8.         var ts = new ArrayList<Thread>();
  9.         for (int i=0; i<5; i++) {
  10.             var t = new Thread() {
  11.                 public void run() {
  12.                     // 执行task:
  13.                     while (true) {
  14.                         try {
  15.                             String s = q.getTask();
  16.                             System.out.println("execute task: " + s);
  17.                         } catch (InterruptedException e) {
  18.                             return;
  19.                         }
  20.                     }
  21.                 }
  22.             };
  23.             t.start();
  24.             ts.add(t);
  25.         }
  26.         var add = new Thread(() -> {
  27.             for (int i=0; i<10; i++) {
  28.                 // 放入task:
  29.                 String s = "t-" + Math.random();
  30.                 System.out.println("add task: " + s);
  31.                 q.addTask(s);
  32.                 try { Thread.sleep(100); } catch(InterruptedException e) {}
  33.             }
  34.         });
  35.         add.start();
  36.         add.join();
  37.         Thread.sleep(100);
  38.         for (var t : ts) {
  39.             t.interrupt();
  40.         }
  41.     }
  42. }
  44. class TaskQueue {
  45.     Queue<String> queue = new LinkedList<>();
  47.     public synchronized void addTask(String s) {
  48.         this.queue.add(s);
  49.         this.notifyAll();  // 唤醒在this锁等待的进程
  50.         /*
  51.         * this.notify();  唤醒一个
  52.         * this.notifyAll();  唤醒全部
  53.         * */
  54.     }
  56.     public synchronized String getTask() throws InterruptedException {
  57.         while (queue.isEmpty()) {
  58.             // 释放锁
  59.             this.wait();
  60.             // 重新获得锁
  61.         }
  62.         return queue.remove();  // 取出列表中的第一个任务
  63.     }
  64. }

ReentrantLock

  1. /*
  2. 我们知道Java语言直接提供了synchronized关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。
  4. java.util.concurrent.locks包提供的ReentrantLock用于替代synchronized加锁*/
  6. // 传统的synchronized代码
  7. public class Counter {
  8.     private int count;
  10.     public void add(int n) {
  11.         synchronized(this) {
  12.             count += n;
  13.         }
  14.     }
  15. }
  17. // ReentrantLock上锁
  18. public class Counter {
  19.     private final Lock lock = new ReentrantLock();
  20.     private int count;
  22.     public void add(int n) {
  23.         lock.lock();  // 加锁
  24.         try {
  25.             count += n;
  26.         } finally {
  27.             lock.unlock();  // 释放锁
  28.         }
  29.     }
  30. }
  32. // 总结：使用ReentrantLock比直接使用synchronized更安全，线程在tryLock()失败的时候不会导致死锁。

使用Condition

Condition提供的await()、signal()、signalAll()原理和synchronized锁对象的wait()、notify()、notifyAll()是一致的，并且其行为也是一样的：

  • await()会释放当前锁，进入等待状态；
  • signal()会唤醒某个等待线程；
  • signalAll()会唤醒所有等待线程；
  • 唤醒线程从await()返回后需要重新获得锁。