JAVA Thread类的基本用法

目录

线程的创建

线程中断

自己设置标志位

使用Thread内置的标志位

线程的等待

线程的休眠和获取线程的实例

休眠

获取实例

---

java标准库中Thread类对操作系统提供的API进行了进一步的抽象和封装

线程的创建

创建线程的方式有多种，我们这里使用继承与Thread类的方法来创建。

class MyTread extends Thread {
    @Override
    public void run() {  //特殊的方法，线程的入口方法
        //run方法就是每个对应的线程的入口
        while (true) {
            System.out.println("hello t");
            try {
                Thread.sleep(1000);  //打断 中断
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

现在我们就创建好了一个线程的入口方法，这个run方法里面的内容我们可以理解为 t 线程的一个入口方法。这个里面就可以执行我们t线程需要执行的逻辑代码了。

我们现在只是创建了一个线程，但是还没有启动，接下来我们启动这个线程

使用t.start方法来启动这个线程

t.start();

启动一个新线程 执行流  在进程中搞了一个流水线，新的流水线开始并发的执行另一个逻辑了。执行的逻辑就是run方法里面的代码逻辑

public class threadDomo1 {
    //多个线程在CPU上调度的执行顺序是随机的，所有打印出来的顺序也不是固定的，因为一个打印对应一个线程
    public static void main(String[] args) {   //main方法对应一个线程，主线程，一个进程里面至少一个线程
        Thread t = new MyTread();
        t.start(); 
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) { //打断 中断
                e.printStackTrace();
            }
        }
    }
}

这个线程就成功启动起来了。

启动起来的这个线程和我们的main线程是并发+并行执行的，他们的执行顺序是随机的，没有顺序的

 至此 我们就成功创建起来了一个线程t

线程中断

自己设置标志位

本质上来说，终止一个线程，办法只有一个，就是让线程的入口方法执行完毕

有些情况下我们可能需要提前结束里面的逻辑，这里我们就需要给线程设置一个标志位

public void run() {  //特殊的方法，线程的入口方法
        //run方法就是每个对应的线程的入口
        while (true) {
            System.out.println("hello t");
            try {
                Thread.sleep(1000);  //打断 中断
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

run方法里面是个死循环，永远不会结束的，就导致这个线程也不会结束

我们可能把while的循环条件设置为一个变量。当我们需要中断线程的时候，就可以通过这个变量让这个循环结束，同而终止线程。

现在我们使用lambda表达式的方式来演示

public class threadDomo {
    //自己设置标志位
    public static boolean flag = false;
    //中断一个线程
    public static void main(String[] args) {
        Thread t = new Thread(()->{
           while (!flag) {
               System.out.println("hello t");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println("t 线程结束");
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
    }
}

因为t线程和main线程是并发执行的，所以在执行main线程的时候会休眠三秒，但是t线程还是在执行的，当三秒之后，main线程执行到flag=true，把这个标志位改为true之后，t线程的while循环条件就会不成立，循环停止，那么t线程也就结束了。

使用Thread内置的标志位

我们一般使用的是Thread内置的标志位来结束线程

public class threadDomo {
    public static void main(String[] args) {
        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();  //启动新的线程
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.interrupt();
        //main线程结束
    }
}

t.interrup()

这个方法就是把Thread内置的标志位更改为true

如果该线程正在阻塞，比如在sleep，就会把阻塞状态唤醒，通过抛出异常的方法来让sleep方法立即结束。

Thread.currentThread() 这个就是获取到t线程的对象

isInterrupted(); 获取标志位 默认为false

我们可以看到t线程和main线程并发执行，同时main线程休眠3秒，t线程还在执行，当3秒之后，main线程停止休眠，就同通过t.interrup()这个方法就是把Thread内置的标志位更改为true，

一旦标志位为true，那么就会唤醒sleep，当sleep被唤醒的时候，sleep会自动把标志位清空，就会重新更改为false，这就导致如果抛出异常之后我们不做任何反应，那么这个线程就不会结束。这里我们使用break来结束循环（结束线程）。

sleep清空标志位是为了让线程本身让自己何时结束有更明确的控制

比如我不想立即结束，我们可以不使用bread。

t.interrupt();  //不是让线程立即结束  ，而是告诉他该结束了 

线程的等待

线程之间是并发执行的，操作系统对线程的调度是无序的，无法判定两个线程谁先执行结束，谁后执行结束

两个线程一起执行，先执行那个线程的内容，这个我们是无法判定的

线程等待的方法：join方法

public class threadDomo9 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
                System.out.println("hello t");
        });
        t.start();
        try {
            t.join(); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("hello main");
    }
}

可以看到我们在main线程里面使用了t.join(),这个方法就是说main线程先等待t线程执行完毕再执行，此时main线程是处于阻塞状态的。

阻塞状态的main线程不会参与CPU的调度，也就是说代码走到这一行就挺停下来了。其他线程不受影响。

线程的休眠和获取线程的实例

休眠

调用sleep方法，这个方法是静态方法，可以通过Thread类名直接调用，参数是毫秒

这个方法会抛出异常，我们需要显示处理异常

try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
            e.printStackTrace();
    }

当前线程代码执行到这里，进行休眠操作3秒 

获取实例

System.out.println(Thread.currentThread());

获取到我们当前线程的引用

public class threadDomo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread());
    }
}