Java - Semaphore 与 Exchanger

Semaphore 

• 控制线程并发数量。
• 内部维护一个等待队列，acquire 使配额减1，release 使配额加1。

package Chapter01;

import java.util.concurrent.Semaphore;

public class _01_Run {
  /*
   * 多进路-多处理：
   * 等待队列中的线程同时，处理任务
   */
  public static void main(String[] args) {
    Service s = new Service();
    MyThread []threads = new MyThread[12];
    for (int i = 0; i < threads.length; i++) {
      threads[i] = new MyThread(s);
      threads[i].start();
    }
  }
  
  static class Service {
    private Semaphore s = new Semaphore(3);
    void say() {
      try {
        s.acquire();
        System.out.println("ThreadName = "+ Thread.currentThread().getName()+
            " 准备中");
        System.out.println("Begin "+ System.currentTimeMillis());
        for (int i = 0; i < 5; i++) {
          System.out.println(Thread.currentThread().getName()+ 
              " 打印  "+ (i+1));
        }
        System.out.println("End " + System.currentTimeMillis());
        s.release();
        System.out.println("ThreadName = "+ Thread.currentThread().getName()+
            "结束");
      } catch (Exception e) {
        // TODO: handle exception
      }
    }
  }
  
  static class MyThread extends Thread {
    private Service s;
    
    public MyThread(Service s) {
      super();
      this.s = s;
    }
    
    @Override
    public void run() {
      s.say();
    }
  }
}

package Chapter01;

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

public class _02_Run {
  /*
   * 多进路-单处理：
   * 等待队列中的线程，按照顺序（阻塞）执行任务
   */
  public static void main(String[] args) {
    Service s = new Service();
    MyThread []threads = new MyThread[12];
    for (int i = 0; i < threads.length; i++) {
      threads[i] = new MyThread(s);
      threads[i].start();
    }
  }
  
  static class Service {
    private Semaphore s = new Semaphore(3);
    private ReentrantLock lock = new ReentrantLock();
    
    void say() {
      try {
        s.acquire();
        System.out.println("ThreadName = "+ Thread.currentThread().getName()+
            " 准备中");
        lock.lock();
        System.out.println("Begin "+ System.currentTimeMillis());
        for (int i = 0; i < 5; i++) {
          System.out.println(Thread.currentThread().getName()+ 
              " 打印  "+ (i+1));
        }
        System.out.println("End " + System.currentTimeMillis());
        lock.unlock();
        s.release();
        System.out.println("ThreadName = "+ Thread.currentThread().getName()+
            "结束");
      } catch (Exception e) {
        // TODO: handle exception
      }
    }
  }
  
  static class MyThread extends Thread {
    private Service s;
    
    public MyThread(Service s) {
      super();
      this.s = s;
    }
    
    @Override
    public void run() {
      s.say();
    }
  }
}

Exchanger

• 线程间交换数据。
• 第一个线程先exchanger，然后等待领一个线程执行exchanger，然后二者交换数据。

package Chapter01;

import java.util.concurrent.Exchanger;

public class _03_Run {
  /*
   * exchange():
   * 1. 线程A 会阻塞
   * 2. 交换数据
   */
  public static void main(String[] args) {
    Exchanger<String> e = new Exchanger<String>();
    ThreadA a = new ThreadA(e);
    ThreadB b = new ThreadB(e);
    a.start();
    b.start();
  }
  
  static class ThreadA extends Thread {
    private Exchanger<String> e;
    
    public ThreadA(Exchanger<String> e) {
      super();
      this.e = e;
    }
    
    @Override
    public void run() {
      try {
        System.out.println("A 中得到B 的值：" + e.exchange("a"));
      } catch (Exception e) {
        // TODO: handle exception
      }
    }
  }
  
  static class ThreadB extends Thread {
    private Exchanger<String> e;
    
    public ThreadB(Exchanger<String> e) {
      super();
      this.e = e;
    }
    
    @Override
    public void run() {
      try {
        System.out.println("B 中得到A 的值：" + e.exchange("b"));
      } catch (Exception e) {
        // TODO: handle exception
      }
    }
  }
}

推荐书目：《Java 编发编程 核心方法与框架》