目录
?（4）有关Thread.interrupted()和Thread.currentThread().isInterrupted()的区别
2.Thread.currentThread().isInterrupted()
5.线程的等待和休眠（join()，sleep()方法的使用）
一.线程的概念
1.什么是线程
一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行着多份代码。
2.引入多线程的目的
为了并发编程，而且线程比进程轻量；线程的创建，销毁，调度比进程创建，销毁，调度快。
3.了解线程和进程的区别
（1）其中进程是包含线程的，每个进程至少有一个线程，是主线程。
（2）进程与进程之间不共享内存空间，进程中的线程之间共享内存空间。
（3）进程是系统分配资源的最小单位，线程是系统调度的最小单位。
4.了解多线程的执行
如果对于一个从0加到1亿这个简单的操作来说，使用之前的main方法来执行，假设这里的执行时间为T,如果使用多线程来并发执行，假设我们这里创建了10个线程，那么相当于是每个线程只需要执行1千万的加法操作即可，大概效率提高了10倍，这就是使用多线程的好处，目的当然是为了提高程序的执行效率。
二.学习使用Java来创建线程
1.学习创建线程的几种方法
这里在创建线时需要注意：首先需要重写run方法，之后启动线程通过调用start方法来进行启动
（1）通过继承Thread类来创建线程
运行结果：
?代码：
package thread.example;
public class CreatThread1 extends Thread {
@Override
public void run() {
System.out.println("线程执行代码");
}
public static void main(String[] args) {
CreatThread1 thread = new CreatThread1();
thread.start();
}
}
（2）实现Runnable接口来创建线程
注意:在实现该接口，需要重写run方法，同时还需要借助Thread来进行启动。
执行结果：
?代码：
package thread.example;
public class CreateThread2 implements Runnable {
@Override
public void run() {
System.out.println("创建的线程执行");
}
public static void main(String[] args) {
Thread thread = new Thread(new CreateThread2());
thread.start();
}
}
（3）使用匿名内部类来创建线程
运行结果：
?代码：
package thread.example;
public class CreateThread {
public static void main(String[] args) {
//使用匿名内部类来创建线程
//直接创建Thread子类对象
Thread thread = new Thread() {
@Override
public void run() {
System.out.println("Thread创建的线程");
}
};
thread.start();
//创建Runnable子类对象
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Runnable创建的线程");
}
});
thread2.start();
}
}
（4）使用lambda表达式创建线程
运行结果：
?代码：
package thread.example;
public class CreateThread3 {
public static void main(String[] args) {
//使用lambda表达式创建线程
Thread thread = new Thread(()->{
System.out.println("lambda表达式创建线程");
});
thread.start();
}
}
三.了解Thread类的常见方法即如何使用
1.Thread类的常见构造方法
| 方法 | 说明 |
| Thread()? | 创建线程对象 |
| Thread(Runnable target） | 使用 Runnable 对象创建线程对象 |
| Thread(String name) | 创建线程对象，并命名 |
| Thread(Runnable target, String name) | ?使用 Runnable 对象创建线程对象，并命名 |
2.Thread常见的属性
| 属性 | 获取方法 |
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否为后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
属性的用途了解：
- ID 是线程的唯一标识，不同线程不会重复。
- 名称是各种调试工具会用到。
- 状态表示线程当前所处的一个情况。
- 优先级高的线程理论上来说更容易被调度到。
- 关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
- 是否存活，即简单的理解，为 run 方法是否运行结束。
- 线程的中断，也就是被阻塞到中断那里等待，直到得到执行权继续执行。
?
3.线程的启动
创建一个线程是通过重写Thread中的run方法来实现，其中的run方法重写后相当于是线程已经准备就绪，只有调用start方法后操作系统才会在底层创建出一个线程，之后才会真正的执行起来。
4.线程的中断
（1）中断线程的2种方法
- 通过共享标记来进行通知（自定义变量作为标记需要使用volatile修饰）
- 通过interrupt()方法进行通知
（2）使用自定义标记来通知线程结束
package thread.example;
public class InterruptThread {
public static volatile boolean flag = false;//设置标记来中断线程
public static void main(String[] args) throws InterruptedException {
//这里使用匿名类来创建线程
Thread thread1 = new Thread(){
@Override
public void run() {
while (!flag) {
System.out.println("线程正在执行");
try {
Thread.sleep(10*100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程执行结束");
}
};
thread1.start();
//通过sleep方法来阻塞另一个线程
Thread.sleep(10*1000);
System.out.println("通知thread1结束");
flag = true;
}
}
（3）使用interrupt()方法来通知线程结束
可以通过使用Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位。因为Thread内部也是通过变量来作为线程中断的标志。
有关该方法的使用如下：
| 方法 | 说明 |
| public void interrupt() | ?中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位 |
| public static boolean interrupted() | ?判断当前线程的中断标志位是否设置，调用后清除标志位 |
| public boolean isInterrupted() | ?判断对象关联的线程的标志位是否设置，调用后不清除标志位 |
package thread.example;
public class InterruptThread2 {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(){
@Override
public void run() {
//两种方法都可以
// while (!Thread.interrupted()) {
while (!Thread.currentThread().isInterrupted()){
System.out.println("thread执行");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
break;//跳出循环
}
}
System.out.println("thread结束");
}
};
thread.start();
Thread.sleep(1000);
System.out.println("线程结束");
thread.interrupt();
}
}
?（4）有关Thread.interrupted()和Thread.currentThread().isInterrupted()的区别
1.Thread.interrupted()
会清除标记位，如下所示：
package thread.example;
public class InterruptThread2 {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(){
@Override
public void run() {
//两种方法都可以
// while (!Thread.interrupted()) {
while (!Thread.currentThread().isInterrupted()){
System.out.println("thread执行");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
break;//跳出循环
}
}
System.out.println("thread结束");
}
};
thread.start();
Thread.sleep(1000);
System.out.println("线程结束");
thread.interrupt();
}
}
2.Thread.currentThread().isInterrupted()
不会清除标记位，如下所示：
package thread.example;
public class InterruptThread3 {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i=0; i<10; i++) {
//清除标记位
System.out.println(Thread.currentThread().isInterrupted());
}
});
thread.start();
thread.interrupt();//相当于是将标记为设为true
}
}
注意：如果使用使用这两种通知方式的时候，如果线程里面包含wait/join/sleep 等方法而阻塞挂起，这时候就会抛出一个异常，从而都会清除标记位，这时候有2种选择，一个是忽略该异常，继续执行；另一个是跳出该异常，结束循环。
5.线程的等待和休眠（join()，sleep()方法的使用）
（1）为什么需要线程进行等待
因为多线程是抢占式随机执行，但是有时候我们需要上一个线程的结果才能执行到下一个线程，这时候就需要线程进行等待，等到上一个执行结束再执行下一个线程。
（2）线程等待的方法
| 方法 | 解释 |
| public void join() | ?等待线程结束 |
| public void join(long millis) | ?等待线程结束，最多等 millis 毫秒 |
| public void join(long millis, int nanos) | ?同理，但可以更高精度 |
（3）线程等待实例
package thread.example;
public class WaitThread {
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(){
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("thread1执行");
}
}
};
Thread thread2 = new Thread(){
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("thread2执行");
}
}
};
thread1.start();
thread1.join();
thread2.start();
}
}
?(4)线程休眠（sleep()）
线程休眠也相当于是阻塞，只不过，这个阻塞是有时间限制的，这个时间可以进行设置，一般休眠时间大于设置的时间。
可以通过Thread.sleep()直接进行调用。
6.观察线程的所有状态
- NEW: 安排了工作, 还未开始行动。
- RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作。
- BLOCKED: 表示等待获取锁，相当于排队等着其他事情。
- WAITING: 表示等待其他线程发来通知，如果没有通知，相当于是死等，相当于排队等着其他事情。
- TIMED_WAITING: 表示等待其他线程发来通知，而且这个等待也有时间限制，相当于排队等着其他事情。
- TERMINATED: 工作完成了。
7.yield（）礼让线程
使用该方法相当于是将当前自己所持有的cpu让出来然后自己重新排队等待。