线程是操作系统中的概念，操作系统中的内核实现了线程这种机制，同时，操作系统也提供了一些关于线程的API让程序员来创建和使用线程。

在JAVA中，Thread类就可以被视为是对操作系统中提供一些关于线程的API的的进一步的封装。

多线程程序的特点

1.每一个线程都是一个执行流

2.CPU对线程的执行是并发执行，同时对线程的执行也是随机调度的。

1.创建线程

1. 通过Thread类创建线程

class  MyThread extends Thread{@Overridepublic void run() {while(true){System.out.println("hello Thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class Demo1 {public static void main(String[] args) throws InterruptedException {Thread t= new MyThread();t.start();while(true){System.out.println("hello main");Thread.sleep(1000);}}
}

我们通过创建一个Thread类的子类MyThread，重写Thread类中的run方法，并通过MyThread子类来创建一个线程的实例化对象，run方法是线程的入口函数。而在主函数中的start方法，表示创建一个线程，且一个线程只能start一次。 

当我们运行上面代码，发现打印的内容的顺序会变换，这是因为多线程的影响，上面代码中有两个线程，分别位t线程和主线程，由于线程在CPU上是并发执行的，且又因为CPU对线程又是随机调度的，这就导致我们两个线程的执行顺序会改变，自然而然打印的顺序也会改变。

2.通过Runnable接口来创建线程

class MyRunnable implements Runnable{@Overridepublic void run() {while (true){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class Demo2 {public static void main(String[] args) {Runnable runnable=new MyRunnable();Thread t=new Thread(runnable);t.start();}
}

3. 通过匿名内部类来创建线程

匿名内部类的写法本质完成了3件事

1.创建了一个Thread的子类，不知到该子类的名字，所以为匿名。

2.{ }代码块里面可以编写子类的定义代码，需要哪些属性，需要重写哪些父类的方法等等。

3. 创建了匿名内部类的实例，并将该实例传给了t1.

3.1 Thread

    public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(){@Overridepublic void run() {while(true){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}};t1.start();while (true){System.out.println("hello main");Thread.sleep(1000);}}

3.2 Runnable接口

public static void main(String[] args) throws InterruptedException {Runnable runnable=new Runnable() {@Overridepublic void run() {while(true){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}};Thread t=new Thread(runnable);t.start();while (true){System.out.println("hello main");Thread.sleep(1000);}}

4.通过Lambda表达式式创建线程-----  ()->{}

由于Java中，方法必须依附于类的体系中，由于Lambda表达式本质就是一个回调函数，所以，为了快速实现这个回调函数，在Java中，就创建了一个函数式接口----- ()->{ },{ }代码块可以写上回调函数所需要功能的代码。

public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{while (true){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();while (true){System.out.println("hello main");Thread.sleep(1000);}}

2.Thread类及常见方法

Thread类是JVM用来管理线程的一个类，也就是说，每个线程都有唯一的Thread类对象与之相关联。在Java中，每一个执行流（线程）都要用一个对象来表示，而Thread类对象就可以用来表示一个线程执行流，JVM会将这些Thread类对象组织起来，进行线程调度和线程管理。

2.1 Thread类常见的构造方法

方法	说明
Thread()	创建线程对象
Thread(Runnable target)	使用Runnable对象创建线程对象
Thread(String name)	创建线程对象，并给线程命名
Thread(Runnable target,String name)	使用Runna对象创建线程对象，并命名
【了解】Thread(ThreadGroup group,Runnable target)	线程可以被用来分组管理，分好的组即为线程组

注释：关于线程的名字，我们可以通过Jconsole来观察。

2.2 Thread的几个常见属性

属性	获取方法
ID	getID()
名称	getName()
状态	getState()
优先级	getPriority()
是否为后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

1.ID是线程的唯一标识，不同线程的ID不会重复

2.名称是各种调试工具用到

3.状态表示线程当前所处的一个状态

4.优先级高的线程理论上更容易被CPU调度到

5.关于后台线程：线程分为后台线程（守护线程）和前台线程（用户线程）。我们需要记住一点：JVM会在一个线程中的所有的前台线程结束之后，JVM才会选择退出（程序终止执行）。也就是说，后台线程的存在不会阻止JVM的终止，相反，前台线程的存在会阻止JVM的终止，即使主线程已经结束。在Java中，线程在默认情况下是后台线程，例如垃圾回收机制就是一种后台线程。但是我们可以通过调用setDaemon(true)方法将一个线程设置为后台线程。

6.是否存活，可以简单理解为run方法是否运行结束。

2.3 如何启动一个线程----start()

一个线程对象被创建出来并不意味着线程就开始运行了。我们需要去调用start方法，接着线程中的run方法就会自动执行，只有run方法执行以后，一个线程才是真正运行起来。而调用了start方法，才是真正的在操作系统的层面建立了一个线程。

如下图：

2.4 中断一个线程

中断一个线程就是让该线程直接停止掉，不会再回复。中断一个线程就是让该线程的run方法（入口方法）尽快结束掉。

目前常见终止线程的方式有以下两种方式：

1.通过共享的标记来沟通

2.调用interrupt()方法来通知

1.通过共享的标记来沟通

该方法是通过设计一个外部成员变量来终止一个线程。

如以下代码

public class Demo9 {public static boolean isFinished=false;//共享标记public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{while (!isFinished){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();Thread.sleep(3000);System.out.println("main尝试终止线程t");isFinished=true;}
}

我们通过isFinished 这个外部成员变量的值来通知操作系统是否终止t线程。

运行结果

注意事项：我们不能将该外部成员变量设置成一个局部变量 。否则会报出以下错误

原因解释：

这就涉及到变量捕获的问题 。简单来说，就是lambda表达式希望可以使用外面的变量，触发“变量捕获”的语法。由于lambda是一个回调函数，执行时机是很久以后，当操作系统真正创建出线程之后，才会执行。很有可能在创建线程的过程中，main线程就已经运行结束了,自然而然，身为局部变量的isFinished就会被销毁了。

为了解决这个问题，Java中的做法是，将被捕获的变量拷贝一份到lambda里面，外面变量的是否销毁，就不影响lambda里面的执行了。拷贝就以为着该变量就不适合被修改，尽管你在外面修改了这一变量的值，也不会影响拷贝到内部的值（本质上，被拷贝的变量和拷贝的变量是两个变量）

这种一边变，一边不变，可能给程序员带来更多的疑惑。所以在Java中就规定了，拷贝的变量就压根不允许被改变。所以后面修改isFinished的值时会报一个isFinished should be final or effectively final 的错，因为在Java中，被final修饰的变量是无法被修改的。

那为什么将isFinished设置为成员变量会没事呢？

因为当isFinished是一个成员变量时，此时触发的语法不在是“变量捕获”，而是切换成“内部类访问外部类的成员”的语法。

那是lambda表达式本质上是一个函数式接口，也相当于是一个内部类。isFinished本身就是一个外部类成员，内部类本来就能够访问外部类的成员。由于成员变量的生命周期是让GC（垃圾回收）来管理的，GC可以自动识别不在被引用的的对象，并将其占用的内存空间释放掉。所以在lambda里面就不必担心变量生命周期失效的问题，也就不必拷贝，也就不必有被final修饰的限制。

2.使用interrupt()方法来通知

Java的Thread类中提供了现成的方法直接进行判定线程方法是否被终止，不需要我们自己在创建了。

方法	说明
public void interrupt()	中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置中断标志位
public static boolean interrupted()	判断当前线程的中断标志位是否设置，调用后清除标志位，不建议使用，静态方法位所有线程共有的
public boolean isInterrupted()	判断对象关联的线程标志位是否设置，调用后不清除标志位

thread收到通知的方式有两种：

1.如果线程因为调用wait/join/sleep等方法而阻塞挂起，则以InterruedException异常的形式通知，清楚中断标志 ，当出现InterruedException的时候，要不要结束进程取决于catch中代码的写法，可以忽略该异常，也可以跳出循环结束进程。

2.否则，只是内部的一个中断标志位被设置了，可以通过isInterrupted()方法判断中断标志是否被设置，不清除中断标志，这种方法通知收到的更及时，即使线程在sleep也可以马上收到。

public class Demo10 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{while (!Thread.currentThread().isInterrupted()){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();//报异常，清楚中断标志//break;//跳出循环，结束进程//啥都不写，忽略异常，进程继续执行}}});t.start();Thread.sleep(3000);System.out.println("main尝试终止线程t");t.interrupt();}
}

注意事项：针对上述代码由于每次循环，线程大部分时间在处sleep状态，当主线程调用interrup()方法时，会大概率唤醒sleep方法， sleep方法就会报InterruedException异常。

正常来说，调用interrupt()方法就会将isInterrupted()方法内部的标志位改为true，但是上述代码，能够把sleep()方法唤醒，sleep方法在唤醒之后就会将isInterrupted()方法内部的标志位的值重新改为false。因此在进程不结束的情况下，如果继续执行到循环的条件判断，就会发现能够继续执行循环中的代码。

2.5 等待一个线程-----join()

有时我们需要等到一个线程完成它的所有操作后，才进行下一步操作。这时候就用到了join()方法。

方法	说明
public void join()	等待线程结束
public void join(long millis)	等待线程结束，最多等待millis毫秒
public void jooin(long millis,int nanos)	同理当精度更高

public class Demo11 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{for(int i=0;i<3;i++){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();System.out.println("main线程在等t线程结束");t.join();System.out.println("t线程结束，main线程结束");}
}

上面的代码中，主线程中线程对象t调用了join方法，这就意味着main线程必须要先等待t线程结束后，才会执行main线程里面的内容。 

运行代码

 

如果调用的是join(long millis)版本，则会表示main线程只会等待t线程millis秒，不管t线程在这段时间内是否终止，main线程不会在等待t线程，而是继续执行自己的任务。 

public class Demo11 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{for(int i=0;i<3;i++){System.out.println("hello t");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}});t.start();System.out.println("main线程在等t2秒");t.join(2000);System.out.println("2秒内t线程没有结束，main线程不在等待，执行main线程");}
}

 

 2.6 获取当前线程引用

方法	说明
public static ThreadcurrentThread()	返回当前线程对象的引用

2.7 休眠当前线程-----sleep()

方法	说明
public static void sleep(long millis)	休眠当前线程millis毫秒
public static void sleep(long millis,int nanos)	可以获得更高精度的睡眠

 关于sleep方法，有一点我们需要记得，因为线程调度是不可控的，所以，sleep方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

 这是因为调用sleep方法，相当于让当前线程，让出cpu的资源。后续休眠时间结束的时候，该线程需要操作系统内核时，操作系统会将该线程重新调度到cpu上，该线程才能继续执行。

换言之，sleep的时间到了，意味着该线程可以被调度，而不是立即执行，所以实际休眠时间会大于等于参数设置的休眠时间。

特殊用法：sleep(0)

sleep(0)意味着让当前线程立刻放弃CPU资源，等待操作系统重新调度。

 3.线程状态

从操作系统的角度来看，进程的有就绪和阻塞的两种状态。

Java线程也是对操作系统中的线程的重新封装。所以，针对线程的状态，Java中也重新进行了封装。

状态	说明
NEW	Thread对象已经创建，但是start()方法没有被调用
Terminated	Thread对象还在，但是内核中线程已经结束
Runnable	就绪状态，线程正在CPU上执行或者线程可以随时去CPU上执行
TIME_WAITING	线程阻塞，阻塞的时间有上限。一般是由于join(时间)，sleep(时间)产生的阻塞。
WAITING	死等，没事时间限制的等待。一般是由于join(),wait()产生的阻塞
BLOCKED	由于锁竞争产生的阻塞