前言
到多线程这一块说明我们【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();
}
}
运行结果为：
