前言

到多线程这一块说明我们【Java Se】专栏就快结束了，感谢一直看过来的兄弟。多线程其实是非常复杂的，我们只是学一个入门，知道有这么个东西并且怎么运用它！

初始多线程

在学习线程之前你得先知道什么是进程，以及进程与线程的关系与区别。

当一个程序被运行时，就开启了一个进程，比如启动了QQ，网易云。而一个进程内可分为多个线程，一个线程其实就是一个指令流，cpu调度的最小单位，由cpu一条一条执行指令。

操作系统调度的最小任务单位其实不是进程，而是线程。进程和线程是包含关系。在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。

某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。

进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。

线程的创建

创建一个线程有两种方法：

1.创建一个Thread类，或者一个Thread子类的对象

2.创建一个实现Runnable接口的类的对象

接下来我们看看如何具体用这两个方法创建线程，这也是本节的重点之处。

Thread类创建线程

用Thread创建一个线程是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。

继承Thread类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

我们先看看Thread类的一些重要方法：

方法说明

Thread() 创建一个线程对象

Thread(String name) 创建一个具有指定名称的线程对象

Thread(Runnable target) 创建一个基于Runnable接口实现类的线程对象

Thread(Runnable target,Stringname) 创建一个基于Runnable接口实现类，并且具有指定名称的线程对象

public void run() 线程相关的代码写在该方法中，一般需要重写

public void start() 启动线程的方法

public static void sleep(long m) 线程休眠m毫秒的方法

public void join() 优先执行调用join()方法的线程

接下来看一下代码案例：

public class Main {
    public static void main(String[] args) {
        //创建一个线程对象
        TestThread1 thread1 = new TestThread1();
        //调用start方法
        thread1.start();
        //main线程，主线程
        for (int i = 0; i < 50; i++) {
            System.out.println("main主线程" + i);
        }
    }
}
//创建线程方式一：继承Thread类，重写run（）方法，调用start（）开启线程
class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 50; i++) {
            System.out.println("白白创建的线程"+i);
        }
    }
}

Runnable接口创建线程

使用Runnable来创建线程，创建一个实现 Runnable 接口的类。

为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

public void run()

你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。

新线程创建之后，你调用它的 start() 方法它才会运行。

当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是实现了Runnable接口的类的实例。

事实上，几乎所有多线程应用都可用Runnable接口方式，接下来看一个代码案例：

class MyThead1 implements Runnable{  //这就是一个多线程的操作类
    private String name;
    public MyThead1(String name) { //定义构造方法
        this.name = name;
    }
    @Override
    public void run(){ //覆写run方法，作为线程的主体操作方法
        for (int x = 0; x <50; x++) {
            System.out.println(this.name+"->"+x);
        }
    }
}
public class Main{
    public static void main(String[] args) {
        MyThead1 myThead1=new MyThead1("白白帅");
        MyThead1 myThead2=new MyThead1("白白牛");
        MyThead1 myThead3=new MyThead1("白白黑");
        new Thread(myThead1).start();
        new Thread(myThead2).start();
        new Thread(myThead3).start();

线程的状态

线程有以下几种状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态

新建状态

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，

join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

Thread类方法

Thread类有许多方法，我们介绍几种常用的方法。

start()

这个方法的作用就是通知线程规划器此现场可以运行了。

要注意，调用start方法的顺序不代表线程启动的顺序，也就是cpu执行哪个线程的代码具有不确定性。。

run()

这个方法是线程类调用start后执行的方法，如果在直接调用run而不是start方法，那么和普通方法一样，没有区别。

isAlive()

是判断当前线程是否处于活动状态。活动状态就是已经启动尚未终止。

getPriority()和setPriority(int newPriority)

首先每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。

Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。

默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

这两个方法是用于获取当前和设置线程的优先级。优先级高的线程得到的cpu多。也就是说，两个等待的线程，优先级高的线程容易被cpu执行。

默认情况下，线程的优先级是5。线程的优先级分为1~10等级。

interrupt()

使用这个方法并不会中断线程。实际上，调用interrupt实际作用是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞状态。

join方法

join方法会使得调用join方法的线程（myThread1线程）所在的线程（main线程）无限阻塞，直到调用join方法的线程销毁为止。也就是说，在这个例子当中，当myThread1线程销毁以后，main线程才会继续执行，在这期间都是阻塞的。

sleep(long millis)

sleep方法的作用就是在指定的时间让正在执行的线程休眠。并不释放锁。

要注意sleep()是一个静态方法

多线程的栗子

龟兔赛跑问题

龟兔赛跑：2000米

要求：

(1)兔子每 0.1 秒 5 米的速度，每跑20米休息1秒;

(2)乌龟每 0.1 秒跑 2 米，不休息；

(3)其中一个跑到终点后另一个不跑了！

程序设计思路：

(1)创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。

(2)创建Rabbit兔子类和Tortoise乌龟类，继承动物类

(3)两个子类重写running方法

(4)本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象。

abstract class Animal extends Thread {
    public int length = 2000;// 比赛长度
    public abstract void runing();
    @Override
    public void run() {
        super.run();
        while (length > 0) {
            runing();
        }
    }
    // 在需要回调数据的地方（两个子类需要），声明一个接口
    public static interface Calltoback {
        public void win();
    }
    // 2.创建接口对象
    public Calltoback calltoback;
}
//创建兔子类
class Rabbit extends Animal {
    public Rabbit() {
        setName("兔子");
    }
    @Override
    public void runing() {
        //兔子速度
        int dis = 5;
        length -= dis;
        System.out.println("兔子跑了" + dis + "米，距离终点还有" + length + "米");
        if (length <= 0) {
            length = 0;
            System.out.println("兔子获得了胜利");
            // 给回调对象赋值，让乌龟不要再跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        try {
            if ((2000 - length) % 20 == 0) {  // 每20米休息一次,休息时间是1秒
                sleep(1000);
            } else {    //没0.1秒跑5米
                sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//创建一个乌龟类
 class Tortoise extends Animal {
    public Tortoise() {
        setName("乌龟");// Thread的方法，给线程赋值名字
    }
    // 重写running方法，编写乌龟的奔跑操作
    @Override
    public void runing() {
        // 乌龟速度
        int dis = 2;
        length -= dis;
        System.out.println("乌龟跑了" + dis + "米，距离终点还有" + length + "米");
        if (length <= 0) {
            length = 0;
            System.out.println("乌龟获得了胜利");
            // 让兔子不要在跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        try {
            sleep(100);      //没0.1秒跑2米
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//创建一个让动物线程停止的类，这里要实现回调接口
class LetOneStop implements Animal.Calltoback {
    // 动物对象
    Animal an;
    // 获取动物对象，可以传入兔子或乌龟的实例
    public LetOneStop(Animal an) {
        this.an = an;
    }
    // 让动物的线程停止
    @Override
    public void win() {
        // 线程停止
        an.stop();
    }
}
//主方法调用类
public class Main {
    /**
     * 龟兔赛跑：2000米
     */
    public static void main(String[] args) {
        // 实例化乌龟和兔子
        Tortoise tortoise = new Tortoise();
        Rabbit rabbit = new Rabbit();
        // 回调方法的使用，谁先调用calltoback方法，另一个就不跑了
        LetOneStop letOneStop1 = new LetOneStop(tortoise);
        // 让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop
        rabbit.calltoback = letOneStop1;
        LetOneStop letOneStop2 = new LetOneStop(rabbit);
        // 让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop
        tortoise.calltoback = letOneStop2;
        // 开始跑
        tortoise.start();
        rabbit.start();
    }
}