Java笔记——Java线程

1.Java线程

进程是操作系统分配资源的最小单元。

线程是操作系统调度的最小单元。

在一个进程中可以创建多个线程，每个线程都拥有自己的程序计数器、堆栈和本地变量（ThreadLocal）。

Java程序再简单也是多线程的，除了main线程外，JVM还会启动很多后台线程（垃圾清理，类加载等等）。

1.1 为什么要使用多线程？

（1）现代处理器采用多核心架构，单线程无法充分利用多核心的计算能力。多线程在多个核心同时执行，可以大大加快程序的处理速度。

（2）在复杂的业务处理中，有些操作（包括一些耗时的操作）可以拆出来在后台线程中异步处理，使用多线程处理可以提高业务的响应速度。

1.2 Java线程的优先级

现代操作系统以时间片为单位，将CPU的执行时间分成非常多的时间片。每次给线程分配CPU的一小段时间片执行，线程执行完时间片之后就会让出CPU资源。单核CPU并发地执行多个线程，多核CPU的每个核心也是并发地执行多个线程，多个线程可以在多核心上并行地运行。

线程的优先级可以让线程获得更多的CPU资源，让线程执行的机会更大。

注意：不要依赖线程的优先级来实现多线程的系统，有些操作系统会忽略Java的线程优先级，使得优先级高的线程并不会比等级低的线程优先执行。

1.3 Java线程的状态

Java线程的状态	说明
NEW	初始状态，线程被创建，但还没有启动，没有调用start()方法
RUNNABLE	运行中，调用start()方法后，包括线程就绪和正在运行
BLOCKED	阻塞状态，线程阻塞在锁上，使用synchronized锁
WAITING	等待状态，当其他线程中断或者唤醒这个线程，这个线程才能从等待状态返回继续执行
TIMED_WAITING	超时等待状态，在WAITING状态的基础上增加超时等待
TERMINATED	终止状态，线程已经执行完run()方法

可以利用jstack工具查看线程的运行状态。

1.4 守护（Daemon）线程

Daemon线程用于做支持性工作，在JVM退出时Daemon线程中的finally块不一定执行，所以在使用Daemon线程时，不要用finally块做关闭操作和资源清理操作。

当JVM中不存在非Daemon线程时，JVM会退出。

2 启动和终止线程

2.1 启动线程的方式

1）继承Thread类，实现（重写）run方法，调用start方法；

2）实现Runnable接口，实现run方法，通过Thread类或者线程池类启动；

3）实现Callable接口，实现call方法，通过FeatureTask创建线程，可以获取执行结果；

4）通过线程池启动线程。

2.2 线程中断

中断就是其他线程通过调用这个线程的interrupt()方法，将这个线程的中断标志属性置为true。

通过调用isInterrupted()方法检测线程是否被中断。

通过调用静态方法Thread.interrupted()清除掉中断标志位，如果线程是中断状态这个方法会返回true，否则返回false。

Java API中申明抛出InterruptedException异常的方法，基本上都是先调用Thread.interrupted()清除中断状态后，再抛出的异常。如果捕获InterruptedException异常，然后检查中断状态，会得到非中断状态。

2.3 过期的方法

方法	说明
suspend()	暂停线程，线程暂停后不会释放持有的资源（锁等），持有资源睡眠，容易引发死锁。
resume()	恢复线程
stop()	停止线程，不保证线程持有的资源正确释放。

suspend()、stop()方法有副作用，以上三个方法不建议使用。

暂停和恢复操作可以使用等待/通知机制来实现。

2.4 安全的终止线程

Java API中申明抛出InterruptedException异常的方法会清除中断标志位，所以建议通过检测volatile型的终止标志位来安全地（优雅地）终止线程，让线程有机会清理资源。

package com.easy.java.lang.threadtest;

public class VolatileFlagShutdownTest {
    public static void main(String[] args) throws InterruptedException {
        Runner runner = new Runner();
        Thread t = new Thread(runner, "Runner-Thread");
        t.start();

        Thread.sleep(9200);
        System.out.println(System.currentTimeMillis() + ", Shutdown Runner-Thread");
        runner.setOn(false);
    }

    private static class Runner implements Runnable {
        private volatile boolean on = true;

        public void setOn(boolean on) {
            this.on = on;
        }

        @Override
        public void run() {
            try {
                while (on) {
                    System.out.println(System.currentTimeMillis() + ", Runner is running");
                    doJob();

                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 资源清理
        }

        private void doJob() {
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

通常业务操作会捕获所有异常，使得通过“检测中断状态和捕获中断异常终止线程”的方式失效。

package com.easy.java.lang.threadtest;

public class InterruptShutdownTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runner(), "Runner-Thread");
        t.start();

        Thread.sleep(9200);
        System.out.println(System.currentTimeMillis() + ", Interrupt Runner-Thread");
        t.interrupt();
    }

    private static class Runner implements Runnable {
        @Override
        public void run() {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println(System.currentTimeMillis() + ", Runner is running");
                    doJob();

                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        private void doJob() {
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

3. 线程间的通信

线程间通信有两种通信机制：共享内存和消息传递

3.1 volatile和synchronized（Lock锁）关键字

volatile 只能保证可见性

synchronized 可以保证可见性、排他性

synchronized使用的锁保存在Java对象头中，每个Java对象都有一个监视器，通过对象监视器实现synchronized。

synchronized运行过程

3.2 等待/通知

（1）使用Object类提供的等待/通知，必须结合synchronized关键字，只有一个等待队列。

（2）使用Lock锁提供的等待/通知，必须结合Lock锁，有多个等待队列。

使用方式都是，必须获取到锁之后等待，等待返回之后要再次检查条件，通知之后必须释放锁。

等待方的执行顺序

（1）获取锁；

（2）如果条件不足，调用wait()方法等待，被通知后要检查条件；调用wait()方法会自动释放锁，被通知从wait()方法返回后，会自动获取到锁。

（3）条件满足执行相应的逻辑。

通知方的执行顺序

（1）获取锁；

（2）改变条件；

（3）通知等待的线程；

（4）释放锁。

等待/通知的运行过程

 

3.3 管道输入/输出流

3.4 Thread.join()

调用Thread.join()方法后，只有对应的线程执行完成之后，才会返回。

也有带超时时间的join()方法。

底层采用等待/通知模式实现。

参考资料

《Java并发编程的艺术》 机械工业出版社 方腾飞 魏鹏 程晓明