一、线程的创建

1、继承Thread类，重写run方法

📝方式一、不借助匿名内部类

1. 1.创建一个继承于Thread类的子类
2. 2.在该子类中重写Thread类中的run方法
3. 3.实例化该子类类型，用父类Thread引用重写了run方法的子类对象，向上转型
4. 4.通过上述引用调用start方法，创建该线程，并将该线程（PCB参与到系统调度中，与其他线程一起进行随机调度执行）

📝方式二、借助匿名内部类

1. 1.借助该匿名内部类将上述三步：子类继承Thread、重写run、创建实例化对象，合并为一步
2. 2. 调用start方法

2、实现 Runnable, 重写 run方法

📝方式一：不用匿名内部类

• 1.创建一个实现了Runnable接口的类
  
  2.用该类去实现Runnable中的抽象方法：run（）
  
  3.创建实现类的对象
  
  4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  
  5.通过Thread类的对象调用start（）
• 

📝方式二、借助匿名内部类

1. 1.把创建一个实现了Runnable接口的类、重写run方法、实例化该类合并
2. 2.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象（这一步还可以与上面的合并）
3. 3.调用start()方法
4. 
5. 

3、使用 lambda 表达式

二、线程中断

1、使用自己的标志位来区分线程是否要结束

2、使用Thread自带的标志位

那么从上面我们可以看到，因为在t线程中调用了sleep方法，使得抛出了异常——在这里我们的程序成功的捕获了该异常，进入了catch语句，打印了异常信息；

那么我们可不可以通过改变catch语句中的内容来对该线程进行不同的处理呢？当然可以！！！

🌰 代码栗子

public class thread {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在运行中...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // e.printStackTrace();打印异常信息
                    //break;  1、立即退出
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                    break; // 2、稍后退出
                    // 不退出，捕获到异常后什么也不干，相当于的忽略了该异常
                }
            }
        });
        System.out.println("线程开始运行");
        t.start();
        Thread.sleep(3000);
        System.out.println("控制该线程退出！");
        t.interrupt();
    }
}

总结

三、线程等待

🌰先来看一个栗子

从这我们可以看到因为在t1、t2start之后，t1、t2和主线程的执行顺序是由操作系统进行随机调度的，那么我们怎样才能让t1、t2线程都执行完了，主线程再记录结束的时间戳呢？

通过join方法！！！

通过join方法我们可以让main线程主动的等待（想让谁阻塞，就再谁的线程里调用join）

四、线程休眠

🌰 实例

五、获取线程实例

🌰栗子一

🌰栗子二

🌰 栗子三