线程同步及通信机制

线程同步

线程同步是保证多线程安全访问竞争资源的一种手段

线程间通信

线程间往往需要协调，共同完全某项工作，需要线程间互相通信，控制不同线程间的状态

线程同步及通信的方式有多种，本文将总结常见的两类方式。

• synchronized、wait、notify

  synchronized方式是最常见的一种线程同步方式，synchronized的位置不同，则同步锁对象不同，需要特别区分不同写法的同步锁对象。

  wait和notify必须和synchronized一同使用，实现线程间的通信，它们都是object的方法，并不是Thread类的方法。wait方法，将导致当前线程被阻塞，释放同步锁，释放cpu使用权，同步锁将被其它线程得到。而notify方法，将唤醒因调用wait方法处于阻塞状态的线程，被唤醒的线程将重新去争取得到同步锁。

  示例：两个线程交替打印AB三次

  private Runnable A = new Runnable() {
    public void run() {
        synchronized (lock) {
            while (countA > 0) {
                System.out.println("A");
                countA --;
                lock.notify();
                try {
                    lock.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            lock.notify();
        }
    }
  };
  
  
  private Runnable B = new Runnable() {
    public void run() {
        synchronized (lock) {
            while (countB > 0) {
                System.out.println("B");
                countB --;
                lock.notify();
                try {
                    lock.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
  };
  

ps：因为最后一次循环中，B调用wait，进入阻塞状态，而A已经执行完所有代码，处理死亡状态了，没有其它线程会唤醒B，B将一直处于阻塞状态，程序不会停止，所以在A内部循环结束后，唤醒一次B，这样程序可以顺序停止

• Lock、Condition
  Lock与上文中的synchronized 作用类似，可实现线程同步功能，而Condition则类似于wait和notify，用于线程间的通信。Lock和Condition是一种更直观的使用方式
  Lock的lock和unLock方法，实现获取同步锁和释放同步锁功能。Condition的await和signal方法，实现线程等待阻塞和唤醒线程的功能。需要注意的是，如果要使用Condition，必须要先获取同步锁才行，否则会报错。
  同上例，使用这种方式实现两个线程顺序打印CD各三次

  Lock lock2 = new ReentrantLock();
  Condition conditionC = lock2.newCondition();
  Condition conditionD = lock2.newCondition();

  private Runnable C = new Runnable() {
    public void run() {
        while (countC > 0) {
            lock2.lock();
            try{
                System.out.println("C");
                countC --;
                try {
                    conditionD.signal();
                    conditionC.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally{
                lock2.unlock();
            }
        }
        lock2.lock();
        conditionD.signal();
        lock2.unlock();
    }
  };

private Runnable D = new Runnable() {
    public void run() {
        while (countD > 0) {
            lock2.lock();
            try{
                System.out.println("D");
                countD --;
                try {
                    conditionC.signal();
                    conditionD.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally{
                lock2.unlock();
            }
        }
    }
  };

其它线程同步方式

仅实现线程同步还有许多方式，在此不再仔细详细，仅简单记录下

• Semaphore semaphore = new Semaphore(3)，Semaphore，信号量，它可以限制当前访问资源的线程个数，在线程访问同步资源时，执行semaphore.acquire()，访问完资源后再执行semaphore.release()，相当于同步锁

• ThreadLocal，ThreadLocal可以想象为一个奇特的键值对，不过它的key是当前调用的线程，可以使用ThreadLocal存储数据，在需要用到的时候再取出来，ThreadLocal存储的数据是正确的，不会出现因未同步而异常，虽然本质上未实现线程同步，但实质上也达到了线程同步的目的。

• 原子量 AtomicInteger，原子量类似于线程安全的容器，内部的实现就是线程安全的，所以也能实现线程同步的效果，它的常用方法为：

  AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
  addAddGet(int dalta) : 以原子方式将给定值与当前值相加
  get() : 获取当前值