先巩固下 Java 线程这些基础操作，再开始多线程编程也不迟

本文为社区首发签约文章，14天内禁止转载，14天后未获授权禁止转载，侵权必究！

前语

专栏前面这十几篇文章咱们把反常处理、Java容器、Lambda、Stream 操作、函数式编程、文件IO这几个用 Java 开发程序需求必备的中心根底常识给咱们梳理了一遍。不过咱们的中心根底还有一大块没有涉及到，便是多线程编程，比如根底的 Java 容器，假如在多线程环境下运用就会有问题，所以 Java 给咱们供给了并发容器，不过有的时分进行多线程编程的时分更多的时分是咱们思维习气还停留在单线程编程的环境下，所以咱们有必要把 Java 多线程的根底给咱们过一遍，让咱们在思维习气上切到多线程编程环境再来学习 Java 供给的各种多线程操控功能也不迟。

这篇文章咱们总结一下 Java线程的根底，打好根底，后面几篇再学多线程的同步操控中的各种锁、线程通信等方面的常识时就会觉得更简单些。

本文的大纲如下：

线程

在计算机体系里每个进程（Process）都代表着一个运转着的程序，比如打开微信，体系就会为微信开一个进程–进程是对运转时程序的封装，是体系进行资源调度和分配的基本单位。

一个进程下能够有许多个线程，还拿微信举比如，咱们用微信的时分除了给好友收发音讯，还能够在里面看公众号，看公众号的时分，也不影响咱们的微信收到其他人发给咱们的音讯，这就以为着运转的微信的进程，还开启了多个线程来一起完结这些子使命。

线程是进程的子使命，是CPU调度和分派的基本单位，用于保证程序的实时性，完结进程内部的并发，线程一起也是操作体系可识别的最小履行和调度单位。

在 Java 里线程是程序履行的载体，咱们写的代码便是由线程运转的。有的时分为了增加程序的履行效率，咱们不得不运用多线程进行编程，虽然多线程能最大化程序运用 CPU 的效率，可是程序用多写成进行使命处理，也是BUG的高发地，主要原因还是多线程环境下有些问题一旦被忽略就会造成履行成果不符合预期的BUG。

平常咱们写代码思考问题时的习气思维是单线程的，写多线程的时分得刻意切换一下才行，这就要求咱们要了解清楚线程在不同运转条件下所表现出来的行为才行。

首先咱们来看一下在 Java 中是怎么表明线程的。

Java 中的线程

到目前为止，咱们写的一切 Java 程序代码都是在由JVM给创立的主线程（Main Thread） 中履行的。Java 线程就像一个虚拟 CPU，能够在运转的 Java 运用程序中履行 Java 代码。当一个 Java 运用程序发动时，它的进口办法 main() 办法由主线程履行。主线程（Main Thread）是一个由 Java 虚拟机创立的运转运用程序的特别线程。

咱们在 Java 里万物皆目标，所以体系的线程在 Java 里也是用目标表明的，线程是类 java.lang.Thread 类或许其子类的实例。在 Java 运用程序内部， 咱们能够经过线程目标创立和发动更多线程，这些线程能够与主线程并行履行运用程序的代码。

下面看一下怎么在 Java 程序里创立和发动线程。

创立和发动线程

在 Java 中创立一个线程，便是创立一个Thread类的实例

  Thread thread = new Thread();

发动线程便是调用Thread目标的start()办法

  thread.start();

当然，这个比如没有指定线程要履行的代码，所以线程将在发动后当即停止。 让线程履行逻辑，需求给线程目标指定履行体。

指定线程要履行的代码

有两种办法能够给线程指定要履行的代码。

• 第一种是，创立Thread类的子类，在子类中掩盖Thread类的run() 办法，在这个run() 办法的办法体里的代码，便是指定给线程去履行的代码。
• 第二种是，将完结 Runnable (java.lang.Runnable) 的目标传递给Thread结构办法，创立Thread实例。

其实，还有第三种给线程指定履行代码的办法，不过细究下来算是第二种办法的特别运用办法，下面咱们看看这三种指定线程履行办法体的办法，以及它们之间的区别。

经过 Thread 子类指定要履行的代码

经过承继Thread类创立线程的过程：

1. 界说 Thread 类的子类，并掩盖该类的 run() 办法。run() 办法的办法体就代表了线程要完结的使命，因而把 run() 办法称为履行体。
2. 创立 Thread 子类的实例，即创立了线程目标。
3. 调用线程目标的 start() 办法来发动该线程。

package com.learnthread;
public class ThreadFirstRunDemo {
    public static void main(String[] args) {
        // 实例化线程目标
        MyThread threadA = new MyFirstThread("线程-A");
        MyThread threadB = new MyFirstThread("线程-B");
        // 发动线程
        threadA.start();
        threadB.start();
    }
    static class MyFirstThread extends Thread {
        private int ticket = 5;
        MyThread(String name) {
            super(name);
        }
        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }
    }
}

上面的程序，主线程发动调用A、B两个线程的start() 后，并没有经过调用wait() 等候他们履行完毕。A、B两个线程的履行体，会并发地被体系履行，等线程都直接完毕后，程序才会退出。

经过完结 Runnable 接口指定要履行的代码

Runnable 接口的界说如下，只有一个 run() 办法的界说：

package java.lang;
public interface Runnable {
    public abstract void run();
}

其实，Thread 类完结的也是 Runnable 接口。 在 Thread 类的重载结构办法里，支撑接纳一个完结了 Runnale 接口的目标作为其 target 参数来初始化线程目标。

public class Thread implements Runnable {
    ...
	public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    ...
    public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }
    ...
}

经过完结 Runnable 接口创立线程的过程如下：

1. 界说 Runnable 接口的完结，完结该接口的 run 办法。该 run 办法的办法体相同是线程的履行体。
2. 创立 Runnable 完结类的实例，并以此实例作为 Thread 的 target 参数来创立 Thread 目标，该 Thread 目标才是真实的线程目标。
3. 调用线程目标的 start 办法来发动线程并履行。

package com.learnthread;
public class RunnableThreadDemo {
    public static void main(String[] args) {
        // 实例化线程目标
        Thread threadA = new Thread(new MyThread(), "Runnable 线程-A");
        Thread threadB = new Thread(new MyThread(), "Runnable 线程-B");
        // 发动线程
        threadA.start();
        threadB.start();
    }
    static class MyThread implements Runnable {
        private int ticket = 5;
        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }
    }
}

运转上面例程会有以下输出，相同程序会在所以线程履行完后退出。

Runnable 线程-B 卖出了第 5 张票
Runnable 线程-B 卖出了第 4 张票
Runnable 线程-B 卖出了第 3 张票
Runnable 线程-B 卖出了第 2 张票
Runnable 线程-B 卖出了第 1 张票
Runnable 线程-A 卖出了第 5 张票
Runnable 线程-A 卖出了第 4 张票
Runnable 线程-A 卖出了第 3 张票
Runnable 线程-A 卖出了第 2 张票
Runnable 线程-A 卖出了第 1 张票
Process finished with exit code 0

既然是给 Thread 传递 Runnable 接口的完结目标即可，那么除了一般的界说类完结接口的办法，咱们还能够运用匿名类和 Lambda 表达式的办法来界说 Runnable 的完结。

• 运用 Runnable 的匿名类作为参数创立 Thread 目标:

Thread threadA = new Thread(new Runnable() {
    private int ticket = 5;
    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
            ticket--;
        }
    }
}, "Runnable 线程-A");

• 运用完结了 Runnable 的 Lambda 表达式作为参数创立 Thread 目标:

Runnable runnable = () -> { System.out.println("Lambda Runnable running"); };
Thread threadB = new Thread(runnable, "Runnable 线程-B");

由于，Lambda 是无状况的，界说不了内部特点，这儿就举个简单的打印一行输出的比如了，理解一下这种用法即可。

获取线程的履行成果

上面两种办法虽然能指定线程履行体里要履行的使命，可是都没有回来值，假如想让线程的履行体办法有回来值，且能被外部创立它的父线程获取到回来值，就需求结合J.U.C 里供给的 Callable、Future 接口来完结线程的履行体办法才行。

J.U.C 是 java.util.concurrent 包的缩写，供给了许多并发编程的东西类，后面会详细学习。

Callable 接口只声明晰一个办法，这个办法叫做 call()：

package java.util.concurrent;
public interface Callable<V> {
    V call() throws Exception;
}

Future 便是对于详细的 Callable 使命的履行进行撤销、查询是否完结、获取履行成果的。能够经过 get 办法获取 Callable 的 call 办法的履行成果，可是要注意该办法会堵塞直到使命回来成果。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Java 的 J.U.C 里给出了 Future 接口的一个完结 FutureTask，它一起完结了 Future 和 Runnable 接口，所以，FutureTask 既能够作为 Runnable 被线程履行，又能够作为 Future 得到 Callable 的回来值。

下面是一个 Callable 完结类和 FutureTask 结合运用让主线程获取子线程履行成果的一个简单的示例：

package com.learnthread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() {
        int i = 0;
        for (i = 0; i < 20; i++) {
            if (i == 5) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }
    public static void main(String[] args) {
        CallableDemo tt = new CallableDemo();
        FutureTask<Integer> ft = new FutureTask<>(tt);
        Thread t = new Thread(ft);
        t.start();
        try {
            System.out.println(Thread.currentThread().getName() + " " + ft.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上面咱们把 FutureTask 作为 Thread 结构办法的 Runnable 类型参数 target 的实参，在它的根底上创立线程， 履行逻辑。所以本质上 Callable + FutureTask 这种办法也是第二种经过完结 Runnable 接口给线程指定履行体的，只不过是由 FutureTask 包装了一层，由它的 run 办法再去调用 Callable 的 call 办法。例程运转后的输出如下：

Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
main 5

Callable 更常用的办法是结合线程池来运用，在线程池接口 ExecutorService 中界说了多个可接纳 Callable 作为线程履行使命的办法 submit、invokeAny、invokeAll 等，这个等学到线程池了咱们再去学习。

Java 线程的运用圈套

在刚开始接触和学习 Java 线程相关的常识时，一个常见的过错是，在创立线程的线程里，调用 Thread 目标的 run() 办法而不是调用 start() 办法。

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
		System.out.println("Anonymous Runnable running");
    }
};
Thread newThread = new Thread(myRunnable);
newThread.run();  // 应该调用 newThread.start();

起先你或许没有注意到这么干有啥错，由于 Runnable 的 run() 办法正常地被履行，输出了咱们想要的成果。

可是，这么做 run() 不会由咱们刚刚创立的新线程履行，而是由创立 newThread 目标的线程履行的 。要让新创立的线程–newThread 调用 myRunnable 实例的 run() 办法，必须调用 newThread.start() 办法才行。

线程目标的基本用法

线程目标常用的办法

Thread 线程常用的办法有以下这些：

办法	描述
run	线程的履行实体，不需求咱们自动调用，调用线程的start() 就会履行run() 办法里的履行体
start	线程的发动办法。
Thread.currentThread	Thread 类供给的静态办法，回来对当时正在履行的线程目标的引证。
setName	设置线程名称。
getName	获取线程名称。
setPriority	设置线程优先级。Java 中的线程优先级的范围是 [1,10]，一般来说，高优先级的线程在运转时会具有优先权。能够经过 thread.setPriority(Thread.MAX_PRIORITY) 的办法设置，默许优先级为 5。
getPriority	获取线程优先级。
setDaemon	设置线程为看护线程。
isDaemon	判别线程是否为看护线程。
isAlive	判别线程是否发动。
interrupt	中止线程的运转。
Thread.interrupted	测试当时线程是否已被中止。
join	能够使一个线程强制运转，线程强制运转期间，其他线程无法运转，必须等候此线程完结之后才能够继续履行。
Thread.sleep	静态办法。将当时正在履行的线程休眠。
Thread.yield	静态办法。将当时正在履行的线程暂停，让出CPU，让其他线程履行。

线程休眠

运用 Thread.sleep 办法能够使得当时正在履行的线程进入休眠状况。 运用 Thread.sleep 需求向其传入一个整数值，这个值表明线程将要休眠的毫秒数。 Thread.sleep 办法或许会抛出 InterruptedException，由于反常不能跨线程传达回主线程中，因而必须在本地进行处理。线程中抛出的其它反常也相同需求在本地进行处理。

public class ThreadSleepDemo {
    public static void main(String[] args) {
        new Thread(new MyThread("线程A", 500)).start();
        new Thread(new MyThread("线程B", 1000)).start();
        new Thread(new MyThread("线程C", 1500)).start();
    }
    static class MyThread implements Runnable {
        /** 线程名称 */
        private String name;
        /** 休眠时刻 */
        private int time;
        private MyThread(String name, int time) {
            this.name = name;
            this.time = time;
        }
        @Override
        public void run() {
            try {
                // 休眠指定的时刻
                Thread.sleep(this.time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.name + "休眠" + this.time + "毫秒。");
        }
    }
}

上面例程开启了3个线程，在各自的线程履行体里让各自线程休眠了 500、1000 和 1500 ms ，线程 C 休眠完毕后，整个程序退出。

线程A休眠500毫秒。
线程B休眠1000毫秒。
线程C休眠1500毫秒。
Process finished with exit code 0

停止线程

当一个线程运转时，另一个线程能够直接经过 interrupt 办法中止其运转状况。

public class ThreadInterruptDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread(); // 实例化Runnable完结类的目标
        Thread t = new Thread(mt, "线程"); // 实例化Thread目标
        t.start(); // 发动线程
        try {
            Thread.sleep(2000); // 主线程休眠2秒
        } catch (InterruptedException e) {
            System.out.println("主线程休眠被停止");
        }
        t.interrupt(); // 中止 mt 线程的履行
    }
    static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println("1、进入run()办法");
            try {
                Thread.sleep(10000); // 线程休眠10秒
                System.out.println("2、已经完结了休眠");
            } catch (InterruptedException e) {
                System.out.println("3、MyThread线程休眠被停止");
                return; // 回来调用途
            }
            System.out.println("4、run()办法正常完毕");
        }
    }
}

假如一个线程的 run 办法履行一个无限循环，而且没有履行 sleep 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt 办法就无法使线程提前完毕。

不过调用 interrupt 办法会设置线程的中止符号，此刻被设置中止符号的线程再调用 interrupted 办法会回来 true。因而能够在线程的履行体循环体中运用 interrupted 办法来判别当时线程是否处于中止状况，然后提前完毕线程。

看下面这个，能够有用停止线程履行的示例

package com.learnthread;
import java.util.concurrent.TimeUnit;
public class ThreadInterruptEffectivelyDemo {
    public static void main(String[] args) throws Exception {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "线程-A");
        thread.start();
        TimeUnit.MILLISECONDS.sleep(50);
        thread.interrupt();
    }
    private static class MyTask implements Runnable {
        private volatile long count = 0L;
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 线程发动");
            // 经过 Thread.interrupted 和 interrupt 合作来操控线程停止
            while (!Thread.interrupted()) {
                System.out.println(count++);
            }
            System.out.println(Thread.currentThread().getName() + " 线程停止");
        }
    }
}

主线程在发动线程-A后，自动休眠50毫秒，线程-A的履行体里会不断打印计数器的值，等休眠完毕后主线程经过调用线程-A的 interrupt 办法设置了线程的中止符号，这时线程-A的履行体中经过 Thread.interrupted() 就能判别出线程被设置了中止状况，随后完毕履行退出。

看护线程

什么是看护线程？

• 看护线程（Daemon Thread）是在后台履行而且不会阻止 JVM 停止的线程。当一切非看护线程完毕时，程序也就停止，一起会杀死一切看护线程。
• 与看护线程（Daemon Thread）相反的，叫用户线程（User Thread），也便对错看护线程。

为什么需求看护线程？

• 看护线程的优先级比较低，用于为体系中的其它目标和线程供给服务。典型的运用便是垃圾回收器。

如何运用看护线程？

• 能够运用 isDaemon 办法判别线程是否为看护线程。
• 能够运用 setDaemon 办法设置线程为看护线程。
  • 正在运转的用户线程无法设置为看护线程，所以 setDaemon 必须在 thread.start 办法之前设置，否则会抛出 llegalThreadStateException 反常；
  • 一个看护线程创立的子线程依然是看护线程。
  • 不要以为一切的运用都能够分配给看护线程来进行服务，比如读写操作或许计算逻辑就不能。

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread(), "线程");
        t.setDaemon(true); // 此线程在后台运转
        System.out.println("线程 t 是否是看护进程：" + t.isDaemon());
        t.start(); // 发动线程
    }
    static class MyThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                System.out.println(Thread.currentThread().getName() + "在运转。");
            }
        }
    }
}

Java 线程的生命周期

java.lang.Thread.State 中界说了 6 种不同的线程状况，在给定的一个时刻，线程只能处于其中的一个状况。 下图给出了这六种状况，注意中间的 Ready 和 Running 都属于 Runnable 安排妥当状况。

以下是各状况的阐明，以及状况间的联络：

• 新建（New） – 没有调用 start 办法的线程处于此状况。此状况意味着：线程创立了但没有发动。

• 安排妥当（Runnable） – 已经调用了 start 办法的线程处于此状况。此状况意味着：线程已经在 JVM 中运转。可是在操作体系层面，它或许处于运转状况，也或许等候资源调度（例如处理器资源），资源调度完结就进入运转状况。所以该状况的可运转是指能够被运转，详细有没有运转要看底层操作体系的资源调度。

• 堵塞（Blocked） – 此状况意味着：线程处于被堵塞状况。表明线程在等候 synchronized 的隐式锁（Monitor lock）。被 synchronized 润饰的办法、代码块同一时刻只允许一个线程履行，其他线程只能等候，即处于堵塞状况。当占用 synchronized 隐式锁的线程开释锁，而且等候的线程取得 synchronized 隐式锁后，就又会从 BLOCKED 转换到 RUNNABLE 状况。

• 等候（Waiting） – 此状况意味着：线程无限期等候，直到被其他线程显式地唤醒。 堵塞和等候的区别在于，堵塞是被动的，它是在等候获取 synchronized 的隐式锁。而等候是自动的，线程经过调用 Object.wait 等办法进入。

• 守时等候（Timed waiting） – 此状况意味着：**无需等候其它线程显式地唤醒，在一守时刻之后会被体系自动唤醒，**线程经过调用设置了 Timeout 参数的Object.wait 等办法进入。

• 停止(Terminated) – 线程履行完 run 办法，或许因反常退出了 run 办法。此状况意味着：线程完毕了生命周期。

下面这张图更生动地展现了线程状况切换的机遇和触发条件（图片来自网络，出处下方饮用链接1）。

引证链接

• dunwu.github.io/javacore/co…
• www.cnblogs.com/pcheng/p/69…