Java 多线程并发

线程常用 `API`

thread.start() ：启动
thread.isAlive()
判断当前线程是否处于活动状态
thread.sleep()
在指定毫秒数内让当前正在执行的线程休眠
thread.getId()：获取线程 ID
yield
放弃当前的 CPU 资源，但放弃多长时间不确定
thread.interrupt()
中断，仅仅是在该线程中打了一个停止的标记，并不是真的停止线程
thread.setPriority()
设置优先级，并不会马上优先执行。线程优先级的代码影响较小，但是优先级高的确实会获取更多的 CPU 资源和执行速度
suspend()/resume
暂停和恢复，作废
stop
停止线程，作废。暴力停止进程，会导致内存无法清理干净，锁的释放也会导致数据不一致
thread.wait()
释放当前锁并等待，执行前必须确保已经获取该对象锁
thread.notify()/.notifyAll()
也必须在同步代码块呢，通知该对象处于锁等待的线程/通知所有。注意：一次 notify 只能被一个处于 wait 的线程接受，即使该对象锁一直空闲，其他 wait 线程也收不到通知，除非使用 notifyAll。notify 后代码块并不会马上释放锁，而是需要将这个 synchronized 代码块执行完毕才会释放锁
thread.join
等待指定线程对象销毁，但是当前线程会进入阻塞状态
Thread.currentThread()
获得当前线程的引用

线程状态机

线程有六种状态：

// java.lang.Thread.java
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

状态说明

NEW
这种情况指的是，通过 New 关键字创建了 Thread 类（或其子类）的对象，该对象此时就处于 NEW 的状态
RUNNABLE
线程正在正常运行中，当然可能会有某种耗时计算 I/O 等待的操作 CPU 时间片切换等，这个状态下发生的等待一般是其他系统资源, 而不是锁， Sleep 等
BLOCKED
多个线程有同步操作的场景，等待获取同步锁。比如正在等待另一个线程的 synchronized 块的执行释放，也就是线程在等待进入临界区
WAITING
线程拥有了某个锁之后调用了 wait 方法，等待 notify/notifyAll 后才能执行下一步操作。这里要区分 BLOCKED 和 WATING 的区别：一个是在临界点外面等待获取锁进入；一个是 wait 后等待 notify
TIMED_WAITING
有时间限制的 WAITING
TERMINATED
线程已经执行完毕了

状态转换图

线程几个特性

进程和线程

线程也被称为轻量级进程。CPU 的基本调度单位是线程而不是进程。同一个进程中所有线程共享进程的内存地址空间，因此这些线程都能访问相同的变量并在同一个堆上分配对象

并发执行顺序

在多线程中，线程的调用具有随机性。也就是 Thread.start() 的执行顺序并不是按照代码顺序来执行的，而是随机的。参考示例：

public class TestThreadStart {

    private static final int THREAD_COUNT = 20;

    public static class MyThread extends Thread{
        private int i = 0;

        public MyThread(int i) {
            super();
            this.i = i;
        }

        @Override
        public void run() {
            System.out.println(i);
        }
    }

    public static void main(String[] agrs) {
        Thread[] threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++){
            threads[i] = new MyThread(i);
            threads[i].start();
        }
    }
}

执行结果是随机的：

xmt@server005:~/test/java$ java TestThreadStart
0
10
9
8
7
6
5
4
3
2
1
19
18
15
17
16
14
13
12
11

并发对共享变量的影响

根据 Java 内存模型，共享变量必须同时满足：原子性，可见性，有序性，或者满足先行发生原则，在并发情况下才是安全的，否则会出现数据异常

public class TestThreadConcurrent {

    private static final int THREAD_COUNT = 5;

    public static class RunnableNotSafe implements Runnable{
        private int count = 5;

        @Override
        public void run() {
            count--;
            System.out.println("Thread name: " + Thread.currentThread().getName() + ", count = " + count);
        }
    }

    public static class RunnableSafe implements Runnable{
        private int count = 5;

        // 使用了同步，确保数据一致
        @Override
        public synchronized void run() {
            count--;
            System.out.println("Thread name: " + Thread.currentThread().getName() + ", count = " + count);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[THREAD_COUNT];
        Runnable notSafe = new RunnableNotSafe();
        Runnable safe = new RunnableSafe();
        // 并发时共享变量的数据异常
        for (int i = 0; i < THREAD_COUNT; i++){
            threads[i] =  new Thread(notSafe, String.valueOf(i));
            threads[i].start();
        }

        Thread.sleep(1000);

        // 使用同步后，能正常输出
        for (int i = 0; i < THREAD_COUNT; i++){
            threads[i] =  new Thread(safe, String.valueOf((char)(i + 'A')));
            threads[i].start();
        }
    }
}

测试结果：

xmt@server005:~/test/java$ javac TestThreadConcurrent.java
xmt@server005:~/test/java$ java TestThreadConcurrent
// 并发时读取脏数据
Thread name: 0, count = 3
Thread name: 4, count = 0
Thread name: 3, count = 1
Thread name: 2, count = 2
Thread name: 1, count = 3
// 同步块输出的正确结果
Thread name: A, count = 4
Thread name: C, count = 3
Thread name: B, count = 2
Thread name: D, count = 1
Thread name: E, count = 0

从示例中，可以看到共享变量 RunnableNotSafe 实例中 count 的自减操作是复合运算，这段代码不具有原子性，而且也不满足先行发生原则，所以是并发不安全的。通过增加 synchronized 关键字修饰后，run() 这段代码满足了：原子性，可见性，有序性，所以并发时安全

线程名称 `API`

this.getName()
当前线程的名称，即 new 出来的线程实例对应的名称
Thread.currentThread().getName()
当前执行线程的名称
thread.setName()
设置当前执行线程的名称

示例：

public class TestThreadName {

    public static class ThreadName extends Thread{

        public ThreadName(){
            System.out.println("Constructor begin!");
            System.out.println("Thread.currentThread().getName(): " 
                    + Thread.currentThread().getName());
            System.out.println("this.getName(): " + this.getName());
            System.out.println("Constructor end!");
        }

        @Override
        public void run() {
            System.out.println("Run begin!");
            System.out.println("Thread.currentThread().getName(): " 
                    + Thread.currentThread().getName());
            System.out.println("this.getName(): " + this.getName());
            System.out.println("Run end!");
        }
    }

    public static void main(String[] args){
        ThreadName threadName = new ThreadName();
        System.out.println("#####################");
        Thread thread = new Thread(threadName);
        thread.setName("Test");
        thread.start();
    }
}

执行结果：

xmt@server005:~/test/java$ javac TestThreadName.java
xmt@server005:~/test/java$ java TestThreadName
Constructor begin!
Thread.currentThread().getName(): main
this.getName(): Thread-0
Constructor end!
#####################
Run begin!
Thread.currentThread().getName(): Test
this.getName(): Thread-0
Run end!

程序解读：

ThreadName threadName = new ThreadName();
new 的第一个线程：ThreadName 对象，该操作是在主线程中执行的，所以构造函数中 Thread.currentThread.getName 打印的是 main 主线程。而 threadName 对象也就是 this.getName 的值为默认初始值 Thread-0。输出：

Constructor begin!
Thread.currentThread().getName(): main
this.getName(): Thread-0
Constructor end!

Thread thread = new Thread(threadName);
这里 new 了第二个线程，本示例比较特殊，仅仅是把 ThreadName 对象当做有名字的 Runnable 在使用。thread 对象名字默认值为 Thread-1
thread.setName("Test");
修改 thread 对象的名字为 Test，所以该线程在执行时（Thread.currentThread().getName()）对应的名字被修改为 Test
thread.start();
thread 对象开始执行，上一步已经将名称修改为 Test，所以输出：
Thread.currentThread().getName(): Test （如果没有上一步修改名称，此处输出 Thread-1）
因为是调用 threadName 对象的 run() 方法，所以 this.getName 表示 threadName 对象的名字，所以输出：
this.getName(): Thread-0

`yield`

public static native void yield(); 放弃当前的 CPU 资源，但放弃多长时间不确定

public static class RunnableYield implements Runnable{

    @Override
    public void run() {
        long begin = System.currentTimeMillis();
        int count = 0;
        for (int i = 0; i < 100000; i++){
            //Thread.yield();
            count += (i + 1);
        }
        long end = System.currentTimeMillis();
        System.out.println("Take time: " + (end - begin));
    }
}

结果分析：如果注释掉 Thread.yield，整个程序执行时间只有 1 毫秒；但是执行 yield 后，执行时间并不固定，有时 15 毫秒，有时 17 毫秒等

线程优先级

Java 中线程的优先级有 10 个等级，优先级越高的线程得到的资源越多，CPU 优先执行优先级较高的线程对象中的任务。线程先级有如下几个特点：

继承性
如果 A 线程启动 B 线程，那么 A 和 B 拥有相同的线程优先级
规则性
线程的优先级和代码执行顺序无关，并不表示优先级高先执行完了再执行优先级低的线程，他们是并发执行的，只是优先级高的可能会先执行完
随机性
优先级高的并不是每次都会先执行完，具有随机性，特别是优先级差别不大的时候

总结：整体来说，线程优先级的代码影响较小，但是优先级高的确实会获取更多的 CPU 资源和执行速度

守护线程 Daemon

Java 线程有两种：用户线程和守护线程
守护线程是一种特殊的线程，它的特性有“陪伴”的意义，陪伴用户线程。当该用户线程不存在了，对应的守护线程也自动销毁。典型的守护线程就是垃圾回收线程（GC）
定义：public final void setDaemon(boolean on)，注意事项：

thread.setDaemon(true) 必须在 thread.start() 之前设置，否则会跑出一个 IllegalThreadStateException 异常。即：不能把正在运行的常规线程设置为守护线程
在 Daemon 线程中产生的新线程也是 Daemon 的，具有传递性
守护线程做耗时操作时，一定要注意用户线程必须等待它结束后才推出。否则用户线程先退出，守护进程来不及执行完毕就会跟随销毁

private static class ThreadDaemon extends Thread{
    @Override
    public void run() {
        try {
            int i = 0;
            while (true) {
                i++;
                System.out.println(i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ThreadDaemon threadDaemon = new ThreadDaemon();
// 先设置守护线程，再开启线程
threadDaemon.setDaemon(true);
threadDaemon.start();

// 主线程等待守护线程执行一段时间
Thread.sleep(5000);
System.out.println("Main end, then thread daemon will be destroyed.");

线程停止

`interrupt` 方法

功能
调用 interrupt() 方法，并不能马上就将线程停止，仅仅是在该线程中打了一个停止的标记，并不是真的停止线程。
有什么用
既然不能直接停止线程，它的作用是什么呢？中断并不能直接终止另一个线程，而需要被中断的线程自己处理中断。

判断线程是否是中断状态

两种方法：

Thread.interrupted()

1
2
3

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

它是 static 的，表示测试当前执行线程是否已经中断。同时，执行后当前执行线程的中断状态标志会被清除，也就是说连续调用两次，如果第一次返回 true，第二次因为前面被清除会返回 fasle。

thread.isInterrupted()

1
2
3

public boolean isInterrupted() {
    return isInterrupted(false);
}

表示某个线程对象是否已经中断，不会清除中断状态标志。

`interrupt` 对`sleep` 的影响

不管是线程先休眠后被打上停止标志，还是先被打上停止标志后执行休眠，都会触发异常 InterruptedException

`stop()` 方法

该方法在 API 中已经被废弃，属于暴力停止进程，同时会抛出 java.lang.ThreadDeath 异常。stop 会导致内存清理工作无法完成，并且对锁定的对象进行了解锁，导致数据无法同步处理，出现数据不一致的问题。

`join` 等待

等待指定线程对象销毁，但是当前线程会进入阻塞状态

原理

public final void join() throws InterruptedException {
    join(0);
}
public final synchronized void join(long millis){
    ...
    while (isAlive()) {
        long delay = millis - now;
        if (delay <= 0) {
            break;
        }
        wait(delay);
        now = System.currentTimeMillis() - base;
    }
    ...
}

从源代码可以看出 join 是一个同步方法，需要获取当前对象的锁，并且通过 wait 方法来实现延时，并释放锁。
线程对象 threadA.join 执行后，threadA 内的所有 synchronized 方法将都需要等待。或者说 threadA 中的同步方法执行后，join 将不会马上执行，需要等待获取同步锁，参考示例：

private static class MyThread extends Thread{
    public synchronized void syncMethod(){
        try {
            System.out.println("MyThread begin");
            Thread.sleep(3000);
            System.out.println("MyThread exit");
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        syncMethod();
    }
}

public static void main(String[] args) throws InterruptedException {
    System.out.println("main begin");
    MyThread myThread = new MyThread();
    myThread.start();
    myThread.join(1000);
    System.out.println("main exit");
}

输出结果为：

main begin
MyThread begin
MyThread exit
main exit

也就是主线程虽然设置了，只等待 myThread 线程 1 秒，但是因为 myThread 中执行的是同步方法，所以 join 因为拿不到对象锁，只能直到同步方法执行完后才能执行 join 等待。但是 join 等待时会判断当前线程是否还存活，因为线程已经执行完退出，所以 join 并没有调用 wait 来等待。

`join/sleep/yield` 的区别

join(long) 使用了 synchronized 来同步，并通过 wait 实现延时，具有释放锁的特点
sleep(long) 使用的是 native 的方法实现的，并不会释放锁，而是一直阻塞到指定时间
yield() 仅仅是放弃当前的 CPU 资源，但放弃多长时间不确定，并不涉及到锁，也不会释放锁。执行后线程状态仍然是 RUNNABLE 状态

`synchronized` 关键字

可以在任意对象及方法上加锁，而加锁的这段代码被称为“互斥区”或“临界区”。在执行这段代码时上锁，执行完毕后释放锁；其他线程访问时需要先检查代码是否上锁，如果上锁则等待直到锁被释放。在 synchronized 方法或者代码块中的代码，是同步执行的；否则就是异步执行

锁对象

锁是针对这个对象的，比如对象有两部分代码都有 synchonized 修饰，只有当第一部分代码执行完释放锁后，第二部分代码才能执行。也就是同一个对象的同步代码，只能串行执行；同一时间只有一个线程能执行。注意：指的是同一个对象

修饰代码块

synchronized (this) 修饰代码块，即获取当前对象锁：

private static class MyObject{
    public void doLongTimeTask(){
        for (int i = 0; i < 50; i++){
            System.out.println("Thread Name: " + Thread.currentThread().getName()
                    + ", i = " + i);
        }

        synchronized (this){
            for (int j = 0; j < 50; j++){
                System.out.println("Thread Name: " + Thread.currentThread().getName()
                        + ", j = " + j);
            }
        }
    }
}

MyObject 的同一个实例，在执行 doLongTimeTask 时， i 的输出是线程并发执行输出的，而 j 的输出这部分代码被修饰为同步，所以 j 只能同步打印。输出结果：

// i 的输出是并发的
Thread Name: A, i = 14
Thread Name: A, i = 15
Thread Name: B, i = 0
Thread Name: A, i = 16
Thread Name: B, i = 1
Thread Name: A, i = 17
Thread Name: B, i = 2
Thread Name: A, i = 18
Thread Name: B, i = 3

// j 的输出是串行输出，顺序执行
Thread Name: A, j = 47
Thread Name: A, j = 48
Thread Name: A, j = 49
Thread Name: B, j = 0
Thread Name: B, j = 1
Thread Name: B, j = 2
Thread Name: B, j = 3

synchronized (this)
使用当前实例对象锁定
synchronized (otherObject)
使用其他对象锁定，这是因为如果一个类中有多个 synchronized 代码段，在大量并发时，不管是否有前后逻辑关系，都需要等待当前对象释放锁才能执行下一个同步代码，所以可以通过锁其他对象来实现并行处理
synchronized(class)
使用当前类锁定，锁定的是当前类，所以所有的 static 同步方法都共用同一个锁
synchronized(String)
String 比较特殊，涉及到常量池特性，当锁定对象为常量池字符串时，实际上是同一个对象。见示例：

public void method(String value){
    synchronized (value) {...}
}

// "AA" 为常量池字符串，所以是同一个对象，同步执行  
method("AA");
method("AA");

// 显示 new 了两个不同的 String 对象，会并发执行
method(new String(AA));
method(new String(AA));

synchronized(wrapperclass)
包装类需要特别注意自动装箱时：数字类型和字符型的包装类在特定范围内共用的是相同对象。char 的 [\u0000, \u007f]：即 ASCII 码表中的 128 个字符；byte/short/int/long 的 [-128, 128)：即 -128 <= x < 128 范围内，共用相同的对象（缓存），示例：

public void method(Object value){
    synchronized (value) {...}
}

// 范围内自动装箱
Integer integer1 = 1;
Integer integer2 = 1;
// integer1 == integer2 is true, 即同一个对象，所以同步执行
method(integer1);
method(integer2);

// 范围外自动装箱
Long long1 = 128L;
Long long2 = 128L;
// long1 == long2 is false, 超出范围即不同对象，并发执行
method(long1);
method(long2);

修饰普通方法

synchronized 直接修饰方法，等同于 synchronized(this) 修饰方法的整段代码，是给当前实例对象上锁：

private static class MyObject{
    public synchronized void methodA(){...}
    public synchronized void methodB(){...}
}

MyObject 的同一个实例中，并发调用了 methodA 和 methodB，这两个方法只能串行执行。比如先执行完 methodA 再执行 methodB

修饰静态方法

synchronized 修饰静态方法，是给当前 Class 类上锁，等同于 synchronized(class)，和给当前对象实例上锁是不一样的

private static class MyObject{
    public synchronized static void methodA(){...}
    public synchronized static void methodB(){...}
    public synchronized void methodC(){...}
    public void methodD(){
        synchronized (MyObject.class){...}
    }
}

其中：methodA, methodB, methodD 都是 MyObject 类锁，所以只能同步执行；但是 methodC 实例对象锁，是可以和他们并发执行的

锁重入

当一个线程获取对象的锁后，再没有释放的情况下可以再次获取这个对象锁，但是其他线程在锁没有释放的前提下是无法获取的。比如：

synchronized 修饰方法时的 methodA 中可以直接调用 methodB
synchronized(Object)
lock.lock()

同时，锁重入支持类继承

锁对象的改变

锁对象属性的改变
仅仅是属性的变化，锁对象并没有变，所以同步执行
锁对象改变
因为对象已经改变，所以锁的是不同对象，并发执行

示例：

// 同一个锁对象，仅仅属性 name/age 的改变，不会影响锁，同步执行
private static class CombinationObject{
    private String name;
    private int age;
    public synchronized static void methodA(){...}
    public synchronized static void methodB(){...}
}

// 锁对象已经改变，并发执行
private static class SimpleObject{
    private String lock = "aaa";
    public void method(){
        synchronized (lock){
            lock = "bbb";
            ...
        }
    }
}

volatile 关键字

关键字 volatile 可以理解为 Java 虚拟机提供的最轻量级同步机制。根据 Java 内存模型，每个线程都有自己的工作线程，会从共享内存中读取出共享变量到自己的线程中，这个时候对共享变量的修改涉及到可见性，否则会出现数据同步异常。但是 volatilte 无法保证操作的原子性，所以需要满足特定的规则才能保证线程安全

特性

保证此变量对所有线程的可见性
禁止指令重排序优化

规则

使用 volatile 保证并发安全需要符合如下两条规则：

运算结果并不依赖变量的当前值，或者确保只有单一线程修改变量的值
变量不需要与其他状态变量共同参与不变约束

示例

使用 volatile 修饰后，可以保证变量的可见性，在不同线程中修改，可以立即可见

private static class VolatileThread extends Thread{
    private volatile boolean isRunning = true;
    public boolean isRunning(){
        return isRunning;
    }
    public void setRunning(boolean running){
        isRunning = running;
    }
    @Override
    public void run() {
        while (isRunning){}
    }
}

// 主线程中修改 isRunning 的值，子线程中立即可见
public static void main(String[] args) throws InterruptedException {
    VolatileThread volatileThread = new VolatileThread();
    volatileThread.start();
    Thread.sleep(500);
    volatileThread.setRunning(false);
}

线程间通信

线程之间的通信机制有两种：共享内存和消息传递。
在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过明确的发送消息来显式进行通信。
Java 的并发采用的是共享内存模型，线程之间的通信总是隐式进行，整个通信过程对程序员完全透明。如果编写多线程程序不理解隐式进行的线程之间通信的工作机制，很可能会遇到各种奇怪的内存可见性问题。

等待/通知机制

方法：

thread.wait()
thread.notify()
thread.notifyAll()

注意事项：

执行前必须已经获取该对象锁，否则会抛出 IllegalMonitorStateException，也就是需要在 synchronized 同步代码块中才能执行
wait 释放当前锁并等待
wait 处于该状态下的对象锁，如果主动 interrupt 后会抛出异常。所以 wait 语句需要 catch InterruptedException
wait(time) 操作 time 后自动唤醒继续执行
notify 通知该对象处于锁等待的线程。一次 notify 只能随机通知一个 wait 的对象，即使该对象锁一直空闲，其他 wait 对象也收不到通知，除非使用 notifyAll
notify 后代码块并不会马上释放锁，而是需要将这个 synchronized 代码块执行完毕才会释放锁
代码编写时，确保 notify 在 wait 之后执行，否则会陷于持续等待的过程

示例：

public class TestCommWaitNotify {
    private static class ThreadA extends Thread{
        private Object lock;
        public ThreadA(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class ThreadB extends Thread{
        private Object lock;
        public ThreadB(Object lock) {
            this.lock = lock;
        }
        @Override
        public void run() {
            synchronized (lock) {
                lock.notify();
                for (int i = 0; i < 5; i++){...}
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        ThreadA threadA = new ThreadA(object);
        threadA.setName("A");
        threadA.start();
        
        // 线程 A 先执行并处于等待过程
        Thread.sleep(200);
        // 线程 B 开始运行并通知
        ThreadB threadB = new ThreadB(object);
        threadB.setName("B");
        threadB.start();
    }
}

管道

在 Java 中提供了各种各样的输入/输出流 Stream，其中管道流 pipeStream 是一种特殊的柳，用于不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道读取数据。通过管道实现线程间通信，不用借助任何临时文件。常见类：

PipedInputSteam/PipedOutputStream
管道字节流
PipedReader/PipedWriter
管道字符流

基于等待/通知机制的读写

读阻塞直到有数据写入才唤醒

public synchronized int read()  throws IOException {
    ...
    while (in < 0) {
        ...
        /* might be a writer waiting */
        notifyAll();
        try {
            wait(1000);
        } catch (InterruptedException ex) {
            throw new java.io.InterruptedIOException();
        }
    }
    ...
}

连接 `connect`

write/read 管道需要连接后，才能确保两个线程使用了相同管道

PipedOutputStream pipedOutputStream = new PipedOutputStream();
PipedInputStream pipedInputStream = new PipedInputStream();
pipedOutputStream.connect(pipedInputStream);

PipedWriter pipedWriter = new PipedWriter();
PipedReader pipedReader = new PipedReader();
pipedWriter.connect(pipedReader);

管道字节流通信示例

初始化 PipedOutputStream/PipedInputStream 并连接
开读线程进入读等待，开写线程写入数据

// 读阻塞
byte[] bytes = new byte[20];
int readLength = inputStream.read(bytes);
while (readLength != -1){
    String newData = new String(bytes, 0, readLength);
    readLength = inputStream.read(bytes);
}
inputStream.close();

// 写数据
for (int i = 0; i < 300; i++){
    String outData = "" + (i + 1);
    outputStream.write(outData.getBytes());
}
outputStream.close();

// 读线程
ThreadRead threadRead = new ThreadRead(readData, pipedInputStream);
threadRead.start();

// 写线程
ThreadWrite threadWrite = new ThreadWrite(writeData, pipedOutputStream);
threadWrite.start();

管道字符流通信示例

流程和字节流通信一样，部分参考代码

// 写数据
for (int i = 0; i < 300; i++) {
    String data = "" + (i + 1);
    pipedWriter.write(data);
}
pipedWriter.close();

// 读等待
char[] chars = new char[20];
int readLength = pipedReader.read(chars);
while (readLength != -1){
    String data = new String(chars, 0, readLength);
    readLength = pipedReader.read(chars);
}
pipedReader.close();

// 读线程             
ThreadRead threadRead = new ThreadRead(readDataCharacter, pipedReader);
threadRead.start();

// 写线程
ThreadWrite threadWrite = new ThreadWrite(writeDataCharacter, pipedWriter);
threadWrite.start();

`ThreadLocal` 和 `InheritableThreadLocal`

基本方法

1 2	threadLocal.set(value); threadLocal.get();

特点

ThreadLocal 共享变量，具有线程隔离性，每个线程存储的值都是私有的
InheritableThreadLocal 共享变量，会继承父线程设置的值

实现原理

线程隔离性
从源码可以看出，线程隔离是因为值存储通过 ThreadLocalMap 来实现的，key 就是当前执行线程，所以不同的线程对应的 value 将会不一样

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

值继承
主线程在 set 时，创建 t.inheritableThreadLocals，子线程在初始化时会拷贝一份主线程设置的值，所以在 get 时能看到值继承效果。但是子线程修改 InheritableThreadLocal 变量的值，主线程中并不会跟着改变

ThreadLocalMap getMap(Thread t) {
   return t.inheritableThreadLocals;
}

void createMap(Thread t, T firstValue) {
    t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}

private void init(...) {
    ...
    if (parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    ...
}

示例

private static ThreadLocal sThreadLocal = new ThreadLocal();
private static InheritableThreadLocal sInheritableThreadLocal = new InheritableThreadLocal();

private static class ThreadA extends Thread{
    @Override
    public void run() {
        System.out.println("ThreadA begin: " + sThreadLocal.get());
        sThreadLocal.set("It is ThreadA running");
        System.out.println("ThreadA exit: " + sThreadLocal.get());
    }
}

private static class ThreadB extends Thread{
    @Override
    public void run() {
        System.out.println("ThreadB begin: " + sThreadLocal.get());
        sThreadLocal.set("It is ThreadB running");
        System.out.println("ThreadB exit: " + sThreadLocal.get());
    }
}

private static class ThreadC extends Thread{
    @Override
    public void run() {
        System.out.println("ThreadC begin: " + sInheritableThreadLocal.get() + ", inheritable from main");
        sInheritableThreadLocal.set("It is ThreadC running");
        System.out.println("ThreadC exit: " + sInheritableThreadLocal.get());
    }
}

public static void main(String[] args) throws InterruptedException {
    ThreadA threadA = new ThreadA();
    threadA.start();
    Thread.sleep(300);

    ThreadB threadB = new ThreadB();
    threadB.start();
    Thread.sleep(300);

    System.out.println("Main thread: begin set value");
    sInheritableThreadLocal.set("It is main thread.");
    System.out.println(sInheritableThreadLocal.get());
    ThreadC threadC = new ThreadC();
    threadC.start();
    Thread.sleep(300);

    System.out.println("Main thread: exit, get value");
    System.out.println(sInheritableThreadLocal.get());
}

运行结果：

ThreadA begin: null
ThreadA exit: It is ThreadA running
// 线程 A 和 B 对共享变量的修改隔离，不会相互影响
ThreadB begin: null
ThreadB exit: It is ThreadB running
// 主线程修改 InheritableThreadLocal 变量
Main thread: begin set value
It is main thread.
// 子线程继承值
ThreadC begin: It is main thread., inheritable from main
ThreadC exit: It is ThreadC running
Main thread: exit, get value
// 子线程对 InheritableThreadLocal 变量的修改，主线程并不会跟着改变
It is main thread.

`lock`

Lock 是 java.util.concurrent.locks 包下的接口，实现提供了比 synchronized 方法和语句可获得的更广泛的锁定操作，它能以更灵活的方式处理线程同步问题。它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。

`ReentrantLock`

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性；它是一种独占锁。
初始化： private Lock lock = new ReentrantLock(); ，常见方法：

public void lock() {...}
获取锁对象，类似 synchronized(object) ，必须用 try 包起来

public void unlock() {...}
释放锁对象，必须在 finally 中执行，如果 try 后面有 catch 捕捉异常，则必须在 unlock 前增加是否 lock 的判断。否则释放锁时因为并没有持有锁抛出异常 IllegalMonitorStateException

try {
    lock.lock()
    Thread.sleep(200);
    ...
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    // 释放前先判断是否持有 
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

public int getHoldCount() {...}
当前线程持有锁的个数，也就是调用 lock 的次数
public final int getQueueLength() {...}
获取等待锁释放的线程估计数，是一个估计值。即 5 个线程并发 lock 方法，1 个正在执行 lock 后的操作，那么返回值为 4 个在等待 lock 释放
public int getWaitQueueLength(Condition condition) {...}
获取等待 condition.await 的线程估计数，也是一个估计值，必须在 lock.lock() 中执行，否则会抛出 IllegalMonitorStateException。即 5 个线程并发都执行了 condition.await ，返回值为 5
public final boolean hasQueuedThreads(Thread thread) {...}
查询指定线程是否正在等待获取此锁定
public final boolean hasQueuedThreads() {...}
查询是否有线程正在等待获取此锁定
public boolean hasWaiters(Condition condition) {...}
查询是否有线程在的等待与此锁定有关的 condition
public final boolean isFair() {...}
判断是不是公平锁
public boolean isHeldByCurrentThread() {...}
查询当前线程是否持有此锁定
public boolean isLocked() {...}
查询此锁定是否被任意线程持有
public void lockInterruptibly() throws InterruptedException{...}
当前线程未被中断则获取此锁定，如果已经被中断则抛出异常
public boolean tryLock() {...}
如果锁定没有被其他线程持有，才获取该锁定
public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException
如果锁定在给定等待时间内没有被其他线程持有，且线程未被中断，则获取该锁定

`Condition`

Condition 替代了 Object 监视器方法的使用（wait/notify/notifyAll），同样代码必须在 lock.lock/lock.unlock 之间，类似 wait/notify 必须要在synchronized 代码段中执行。在 wait/notify/notifyAll 方法进行通知时，通知线程是有 JVM 随机选择的。但是 Condition 拥有更好的灵活性，可以实现多路通知，可以选择性进行线程通知，在调度线程上更加灵活。

功能类比：

condition.await --> object.wait
condition.signal --> object.notify
condition.signalAll --> object.notifyAll

常见方法：

void awaitUninterruptibly();
不能被打断的等待，直到 signal 信号出现
boolean awaitUntil(Date deadline) throws InterruptedException;
在 await 基础上加了个等待的时间限制

`ReentrantLock` 和 `Condition` 结合示例

生产者消费者模型：

private static final int NUM = 5;
private static class MyObject {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean hasValue = false;

    public void produce(){
        try {
            lock.lock();
            while (hasValue){
                condition.await();
            }
            System.out.println("produce: **");
            hasValue = true;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume(){
        try {
            lock.lock();
            while (!hasValue){
                condition.await();
            }
            System.out.println("consume: ##");
            hasValue = false;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

private static class ThreadProduce extends Thread{
    private MyObject myObject;

    public ThreadProduce(MyObject myObject) {
        this.myObject = myObject;
    }

    @Override
    public void run() {
        for (int i = 0; i < NUM; i++) {
            myObject.produce();
        }
    }
}

private static class ThreadConsume extends Thread{
    private MyObject myObject;

    public ThreadConsume(MyObject myObject) {
        this.myObject = myObject;
    }

    @Override
    public void run() {
        for (int i = 0; i < NUM; i++) {
            myObject.consume();
        }
    }
}

public static void main(String[] args) {
    MyObject myObject = new MyObject();
    ThreadProduce threadProduce = new ThreadProduce(myObject);
    threadProduce.start();
    ThreadConsume threadConsume = new ThreadConsume(myObject);
    threadConsume.start();
}

实现效果：生产者和消费者交替执行，每生产一个就消费掉

produce: **
consume: ##
produce: **
consume: ##
produce: **
consume: ##

公平锁和非公平锁

公平锁
表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得 FIFO 的先进先出顺序
非公平锁
一种获取锁的抢占机制，是随机获取锁。Java 中默认都是非公平锁

示例：

1
2
3

// true 表示公平锁，false 表示非公平锁  
private Lock lock = new ReentrantLock(true);
private Lock lock = new ReentrantLock(false);

`ReentrantReadWriteLock` 读写锁

ReentrantLock 具有完全互斥排他的效果，即同一个时间只有一个线程能执行 lock 后的任务，虽然保证了共享变量的线程安全性，但是效率较低。而ReentrantReadWriteLock 具有读写锁特性（有两个锁），可以提高效率。基本概念及特性：

读锁
读相关的锁（`reentrantReadWriteLock.readLock()），共享锁，读锁不互斥
写锁
写相关的锁（`reentrantReadWriteLock.writeLock()），排他锁。读锁与写锁互斥，写锁与写锁互斥；只要持有了写锁，不管是先写后读还是先读后写，都会互斥

单例模式多线程

立即加载/饿汉模式

类加载的时候就直接将对象创建并立即初始化（static），因为对象创建的比较急，即使不需要使用也会被初始化，即所谓的“饿汉”模式。特点：

优点：线程安全
缺点：即使不需要也会被实例化，大量使用会造成资源浪费

示例：

// 饿汉式，static，定义时直接初始化
private static MyObject myObject = new MyObject();

// 或者使用静态加载
//static {
//    myObject = new MyObject();
//}

// 使用时，因为在类加载过程中就已经实例化，并发调用安全
public static MyObject getInstance(){
    return myObject;
}

延迟加载/懒汉模式

在需要实例时才初始化，延迟加载即所谓的“懒汉”模式。特点：

缺点：线程不安全，需要加锁确保并发安全
优点：需要使用时才实例化，提高资源利用率

基本用法，存在线程不安全问题：

private static MyObject myObject;
public static MyObject getInstance(){
    if (myObject == null){
        myObject = new MyObject();
    }
    return myObject;
}

懒汉模式：`synchronized` 修饰方法

懒汉模式中使用 synchronized 修饰方法，可以解决并发安全问题。
缺点：如果单例已经被初始化完毕，每次使用时却还需要同步获取，效率并不高。

private static MyObject myObject;
public synchronized static MyObject getInstance(){
    if (myObject == null){
        myObject = new MyObject();
    }
    return myObject;
}

懒汉模式：`synchronized` 同步代码块，双检锁

懒汉模式中使用 synchronized 同步代码块，必须使用双检锁的模式，才能确保线程并发安全。双检锁：DCL- Dounble Check Lock，正确示例：

// volatile 禁止指令重排序
private volatile static MyObject myObject;

public static MyObject getInstance(){
    if (myObject == null){ //step1
        synchronized (MyObject.class) {  //step2
            if (myObject == null) {  //step3
                myObject = new MyObject();  //step4
            }
        }
    }
    return myObject;
}

代码解析：

step1/step3 两次检测非空，即双检锁
step2 只有在初始化时加锁，提高效率
step4 在 JMM 内存模型中，存在编译器对指令的优化。这一步并非原子操作，实际上被分解为三步：给实例分配存储空间；new 初始化存储空间；myObject 指向存储空间（此时 myObject 为非空了）。在指令优化时第二步和第三步是乱序的，所以当正在执行 step4 的线程在乱序的情况下，先执行了指向存储空间，导致 myObject 非空，其他线程在读取时认为非空就直接使用了会出错。所以针对这个问题，需要使用 volatile 关键字来修饰 myObject 共享变量，禁止指令重排序。

懒汉模式：静态内置类实现

饿汉模式中使用静态内置类来初始化实例，静态内置类只有在第一次引用时才会被加载到内存，间接实现了懒汉模式。示例：

private static class MyObject{
    // 静态内置类，只有在第一次引用时才加载
    private static class MyObjectHandler{
        private static MyObject myObject = new MyObject();
    }

    private MyObject(){

    }

    public static MyObject getInstance(){
        return MyObjectHandler.myObject;
    }
}

序列化与反序列化对静态内置类的影响

使用静态内置类实现懒汉模式，提供了资源利用率。但是在序列化和反序列化中，反序列化会克隆这个实例，不满足单例模式的特性了。
解决方案：在类中实现 readResolve 方法。该方法是 ObjectInputStream.readObject() 读取时，会判断类中是否定义了，如果定义则会通过反射调用 readResolve 返回的对象替换反序列化中创建的对象，这样就做到了确保单例模式的唯一性。

private static class MyObject implements Serializable{
    private static final long serialVersionUID = -6683402613942762249L;
    private static class MyObjectHandler{
        private static MyObject myObject = new MyObject();
    }

    private MyObject(){...}

    public static MyObject getInstance(){
        return MyObjectHandler.myObject;
    }

    // ObjectInputStream.readObject() --> readOrdinaryObject
    private Object readResolve() throws ObjectStreamException {
        return MyObjectHandler.myObject;
    }
}

懒汉模式：枚举类的实现

枚举中我们明确了构造方法限制为私有，在我们访问枚举实例时会执行构造方法，同时每个枚举实例都是 static final 类型的，也就表明只能被实例化一次。枚举也提供了序列化机制，所以不存在内部静态类在读取时需要重写 readResolve 的问题。在《Effective Java》 中提到：单元素的枚举类型已经成为实现 Singleton 的最佳方法。

// 实现方法一：枚举类作为帮助类实现单例
private static class MyObject{
    private enum Helper{
        INSTANCE;

        private MyObject myObject;
        Helper(){
            myObject = new MyObject();
        }

        public MyObject getInstance(){
            return myObject;
        }
    }
    
    private MyObject(){...}

    public static MyObject getInstance(){
        return Helper.INSTANCE.getInstance();
    }
}

// 方法二：直接设计一个枚举类，并且支持序列化和反序列化
private enum MyObjectSerializable {
    INSTANCE;

    public void method() {

    }
}

线程组

概念

作用
可以批量管理线程或线程组对象，有效的对线程或线程组对象进行组织。
结构图

线程对象关联线程组

1 级关联
父对象中有子对象，但不创建孙对象。非常常用，我们在线程池技术中，线程工厂创建线程时基本都是 1 级关联，可以对零散的线程进行有效的组织和规划。
多级关联
父对象中有子对象，子对象中还有子对象，也就是出现了子孙对象。多级关联就是结构图中的树结构，但是这种级联方式并不常见，层次过多会导致管理复杂。

1 级关联示例：

RunnableA runnableA = new RunnableA();
RunnableB runnableB = new RunnableB();
ThreadGroup threadGroup = new ThreadGroup("TestThreadGroup");
Thread threadA = new Thread(threadGroup, runnableA);
Thread threadB = new Thread(threadGroup, runnableB);
threadA.start();
threadB.start();
System.out.println("ThreadGroup Active Count: " + threadGroup.activeCount());
System.out.println("ThreadGruop Name: " + threadGroup.getName());

Thread.sleep(3000);
threadGroup.interrupt();

常用 `API`

threadGroup.getName()：获取线程组名称
threadGroup.activeCount()：获取线程组中活动线程估计数
threadGroup.interrupt()：中断线程组中所有线程
threadGroup.getParent()：获取线程组的父线程组

自动归属特性

线程组在构造时，如果不显示指定父线程组，默认为自动归属到当前线程组。
ThreadGroup threadGroup = new ThreadGroup("TestThreadGroup");：自动归属到当前 main 线程组中。

参考文档

Java多线程编程核心技术–高洪岩
图文并茂简单易懂的博客1
图文并茂简单易懂的博客2

线程常用 API