Thread 类是 JVM 用来管理线程的一个类，每一个线程都有一个唯一的 Thread 类与之关联。Java中通常使用 Thread类来进行线程调度，线程管理。
目录
一、Thread 的常见构造方法
二、Thread 的几个常见属性
·理解线程是否存活：
·理解前台线程与后台线程：
三、启动一个线程
四、中断一个线程
1、通过共享的标记来进行沟通
2、调用interrupt() 方法来通知
五、等待一个线程
六、获取当前线程的引用
七、休眠当前线程
一、Thread 的常见构造方法
Thread() 创建线程对象
Thread(Runnable target) 使用Runnable对象创建线程对象
Thread(String name) 创建线程对象,并命名
Thread(Runnable target,String name) 使用Runnable对象创建线程对象,并命名
Thread t1 = new Thread();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程运行…………");
}
});
Thread t3 = new Thread("三号线程");
Thread t4 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程运行…………");
}
},"四号线程");二、Thread 的几个常见属性
·ID 是线程的唯一标识，不同线程的 ID 不同
·线程的名称在各类调试工具调试时会用到
·状态表示当前线程所处的一个情况
·优先级高的线程理论上来说会更容易被调度
·关于后台线程：JVM 会在一个进程的所有非后台线程结束后，才会结束运行
·是否存活，就是run方法是否运行结束了
·理解线程是否存活：
public static void main(String[] args) { Thread thread = new Thread("我是线程"); thread.start(); System.out.println(thread.getId()); System.out.println(thread.getName()); System.out.println(thread.getState()); System.out.println(thread.getPriority()); System.out.println(thread.isDaemon()); System.out.println(thread.isAlive()); System.out.println(thread.isInterrupted()); }举一个例子有利于我们更好的理解：
public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(() -> { for (int i = 0; i < 10; i++) { try { System.out.println(Thread.currentThread().getName() + "我还存活"); System.out.println(Thread.currentThread().isAlive()); Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } System.out.println(Thread.currentThread().getName() + "我即将死去"); },"111号线程~"); thread.start(); thread.join(); System.out.println(thread.isAlive()); }以上代码的运行结果是 打印十个 ”我还存活“ 后结束代码，在 run方法执行结束前，线程都是存活着的，在run方法结束后，线程也结束了他的生命周期。
·理解前台线程与后台线程：
前台线程：前台线程如果不结束运行，此时 Java 进程一定不会结束
后台线程：后台进程即使仍在执行，也不能阻止 Java 进程 结束
在 Java 中，main 线程就是前台线程。另外，程序员创建出来的线程，一般情况下都是前台线程。我们可以通过 setDeamon 方法来把线程设置为后台线程。
代码示例：
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("running……");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
}未将 thread 线程设置为后台线程时，执行结果如图所示。进程会在thread线程结束后才结束。
将 thread 线程设置为后台线程后，执行结果如图所示。进程会在main线程结束后就结束。
注意：对线程进行操作要在 start() 操作开始前，否则无法成功设置！
三、启动一个线程
我们已经会使用Thread类来创建一个线程对象，但线程被创建出来并不意味着线程就开始运行了。调用 start() 方法，才真的在操作系统底层创建出一个线程，线程才真正开始执行。一个Thread 对象只能调用一次 start() 方法。
如果是像以下这样一串代码：
public static void main(String[] args) {
Thread thread = new Thread(() -> {
while (true) {
System.out.println("线程执行中……");
}
});
}点击了运行，我们会发现程序并没有打印任何内容
当加上 start() 方法后：
public static void main(String[] args) {
Thread thread = new Thread(() -> {
while (true) {
System.out.println("线程执行中……");
}
});
thread.start();
}线程才真正跑起来了：
四、中断一个线程
当线程执行时，没有运行完是不会结束的，当遇到紧急情况需要中断线程时，就需要通过一些机制来中断。在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的机制——中断。在这边可以直接把“中断”理解为“终止”。
在 Java 中，“中断” 都只是“建议”，真正要不要终止，是由线程本身来决定的！
目前常见的方法有以下两种：
1、通过共享的标记来进行沟通
2、调用interrupt() 方法来通知
1、通过共享的标记来进行沟通
使用自定义的变量来作为标志位，给标志位加上 volatile 关键字
public class Demo{
private static class MyRunnable implements Runnable {
public volatile boolean flag = false;
@Override
public void run() {
while (!flag) {
System.out.println("线程还在运转~");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程即将结束！");
}
}
public static void main(String[] args) throws InterruptedException {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
Thread.sleep(10*1000);
myRunnable.flag = true;
}
}这样子就可以通过修改标识位的方法来中断线程了。
但这个方法有一个缺点：
如果线程 sleep了好几秒的话，此时main线程是无法及时将线程终止。
2、调用interrupt() 方法来通知
使用 Thread.interrupted() 或 Thread.currentThread().isInterrupted() 代替标志位。
发起线程中断请求，把线程的中断标识设置为了true
public class Main {
public static void main(String[] args) {
Thread thread =new Thread(() -> {
//通过 currentThread() 方法拿到当前线程示例
//使用 isInterrupted() 方法获得线程内置的标志位（boolean）
while (!Thread.currentThread().isInterrupted()) {
System.out.println("running……");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//如果我们想进行其他操作，可以对这部分代码进行修改。符合自己的需求。
throw new RuntimeException(e);
}
}
});
thread.start();
//在等待 3s 后，中断线程
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//立即让 sleep 抛出一个 InterruptedException异常，不会再等待，直接唤醒
thread.interrupt();
}
}
通过这个方法，就相当于方法一中的把 boolean值设置为 true。但与方法一不同的是，即使线程此时正在睡眠，也会直接唤醒线程并提醒线程终止。
注意：
这边由于interrupt 将标志位修改为true且唤醒sleep后，sleep被唤醒的同时，又会将标志位修改为 false，并会抛出一个异常。目的是让程序员可以自行选择下一步要执行什么操作。
程序将控制权移交给程序员，进程下一步是要继续执行还是立即终止，由程序员自己写代码来实现~
（如果在代码中没有sleep的情况下，interrupt方法就只是把标志位设置为true，但具体操作也需要程序员自己来执行。）
五、等待一个线程
有时，我们需要等待一个线程完成他的工作后，才能进行自己的下一步工作。此时我们就需要一个方法明确等待线程的结束。这边就需要用到我们的 join() 方法。
public class Demo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("running~");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
thread.join(); //如果这边把 join 注释掉了，就会在线程未结束时就打印 “线程结束”
System.out.println("线程结束~");
}
}加不加 join() 对比（左图加了 右图没加）：
join的几个方法：
六、获取当前线程的引用
方法：
使用示例：
七、休眠当前线程
方法：
public static void sleep(long millis) throws InterruptedExecption
休眠该线程（以毫秒为单位）
public static void sleep(long millis，int nanos) throws InterruptedExecption
更高精度休眠该线程（以纳秒为单位）
代码示例：
public class Main {
public static void main(String[] args) throws InterruptedException {
long time1 = System.currentTimeMillis();
Thread.sleep(3*1000);
long time2 = System.currentTimeMillis();
System.out.println(time2 - time1);
}
}
运行结果可看到，当前代码的运行时间为3秒。
相关知识点文章：
Java EE：Thread创建线程的五种写法（源码详解）:
http://t.csdnimg.cn/C7V3o
Java EE：Thread类中run和start的区别:
http://t.csdnimg.cn/LkTdX
