【多线程】-- Thread类

Thread类

Thread类是java提供的管理线程的类，基础的方法如下：

方法	描述
public void start()	启动线程，然后调用该线程的run方法
public void run()	线程的入口方法，单独调用它不会启动线程，只会执行run方法内的任务
public static Thread currentThread()	获取当前对象的引用
public void interrupt()	中断线程，将线程的中断标志位设置为true
public boolean isInterrupted()	判断线程是否被中断
public void join()	等待线程结束，无参则一直等待。谁等？等谁？– 谁调用那么主线程就等谁，其他子线程不调用主线程不管！！！
public void join(long millisec)	等待线程结束，最多等待 millisec 毫秒
public static void sleep(long millisec)	线程休眠，最多休眠 millisec 毫秒

---

thread类方法综合演示：

	public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) { // 获取线程实例并判断是否别中断
                System.out.println("Thread t");
                try {
                    Thread.sleep(1000); // 线程t线程休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        t.start(); // 启动线程

        try {
            Thread.sleep(3000); // 线程main线程休眠3秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt(); // 中断线程t

        try {
            t.join(); // 等待线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread main");
    }

运行结果：

Thread t
Thread t
Thread t
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at Thread01.lambda$main$2(Thread01.java:50)
	at java.lang.Thread.run(Thread.java:748)
Thread main

• 注解：线程t和主线程main并行或者并发执行，线程t绝大多数时间是处于休眠状态，当主线程main休眠3秒结束，执行中断线程t，随之将线程的标志位设置为true，线程t抛出睡眠异常，从睡眠状态唤醒，注意这时又把标志位设置为了false，线程t因为在catch异常则break了否则还会循环执行下去。线程t结束主线程main开始执行。

---

1.创建线程

通过Thread类和Runnable接口创建线程：进程与线程：

1. 子类继承或子类实现实现
2. 直接匿名内部类
3. Lambda 表达式

---

2.线程等待

等待线程结束，无参则一直等待；有参等待线程结束，最多等待 millisec 毫秒。

• 谁等？等谁？– 在main函数中不止线程1和线程2还有主线程main，谁调用那么当前主线程就等谁，其他子线程不调用主线程不管！！！

实例1：主线程等待线程2

	public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread t1");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("Thread t2");
        });
        t1.start();
        t2.start();
        t2.join();
        System.out.println("Thread main");
    }

运行结果：

• 主线程一定会在线程t2后面，至于t1和t2谁先执行，或者t2执行后，t1和main谁先执行看CPU的调度！！！（你以为你会了？会个🐔）

测试结果一：
Thread t1
Thread t2
Thread main

测试结果二：
Thread t2
Thread t1
Thread main

(**)测试结果三：其他子线程不调用join()主线程main不管！！！
Thread t2
Thread main
Thread t1

实例2：创建三个线程a,b,c，按照c,b,a的顺序打印线程的名字

	public static void main(String[] args){
        Thread t3 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        }, "c");
        
        Thread t2 = new Thread(() -> {
            try {
                t3.join(); // 当前的主线程是t2，所以是t2等t3，也正如下面getName()所示。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }, "b");
        
        Thread t1 = new Thread(() -> {
            try {
                t2.join();// 当前的主线程是t1，所以是t1等t1，也正如下面getName()所示。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }, "a");
        
        t1.start();
        t2.start();
        t3.start();
    }

结果：

c
b
a
（辽宁总冠军🏆🏆🏆）

• 注解：

1. 当前的“主线程”是谁，那么谁调用join则“主线程”等待它！
2. 由于打印顺序是倒序，那么创建的时候要逆序创建保证当前线程等待的线程存在，再start线程之前，main线程是按从上到下的顺序执行代码的。

---

3.线程休眠

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

运行结果：

测试结果一：
Thread main
Thread t1
Thread t2

测试结果二：
Thread main
Thread t2
Thread t1

• 注意虽然线程1和2都休眠1s，但是1s后谁上CPU核心由CPU调度，也并不是1s一到就都上CPU，只是在这1s中之内不能上CPU！！！