线程是操作系统中的概念，操作系统中的内核实现了线程这种机制，同时，操作系统也提供了一些关于线程的API让程序员来创建和使用线程。
在JAVA中，Thread类就可以被视为是对操作系统中提供一些关于线程的API的的进一步的封装。
多线程程序的特点
1.每一个线程都是一个执行流
2.CPU对线程的执行是并发执行，同时对线程的执行也是随机调度的。
1.创建线程
1. 通过Thread类创建线程
class MyThread extends Thread{
@Override
public 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{
@Override
public 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(){
@Override
public 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() {
@Override
public 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 | 由于锁竞争产生的阻塞 |
