线程同步及通信机制

作者: 某昆 | 来源:发表于2016-12-21 19:03 被阅读52次

线程同步及通信机制
最详细分析Java 内存模型
Java内存模型
线程间通信
java内存模型
2.Java内存模型
并发编程线程通信之管道流
JVM 深入理解(三)内存模型上
啃碎并发（九）：内存模型之基础概述
java内存模型

线程同步

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

线程间通信

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

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

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() : 获取当前值