【多线程】Thread的常见属性 | 终止线程 | 等待线程 | 休眠线程 | 线程安全

翁佳明

已于 2024-04-10 21:18:22 修改

阅读量965

点赞数 8

分类专栏：多线程文章标签：安全 java 线程 Thread join sleep

于 2024-04-10 21:07:49 首次发布

本文链接：https://blog.csdn.net/m0_64003319/article/details/137611007

版权

多线程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录

一、Thread的方法

创建线程的时候，可以指定name

    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (true){
                System.out.println("这是我的新线程");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"这是新线程");
        t.start();
    }

在这里插入图片描述

name不影响线程的执行，只是取了一个名字，方便后续区分
线程的入口方法执行结束，就会销毁。在start执行完后，main方法执行结束。主线程就没有了。

Thread的常见属性

	ID getid() //线程的身份标识
	名称 getName()
    状态 getState()
    优先级 getPriority()  //微观调度
    是否后台线程 isDaemon()
    是否存活 isAlive()
    是否被中断 isInterrupted()

标识一个进程中唯一的线程。是Java给这个线程分配的，不是操作系统api提供的线程id、也不是PCB的id

后台线程（守护线程）

一个Java进程中，如果前台线程没有执行结束，那么整个进程不会结束。

后台线程不结束，不影响整个进程的结束。

后台线程不影响进程的结束

默认情况下，一个线程就是前台线程

设置后台线程

    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (true){
                System.out.println("这是我的新线程");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"这是新线程");
        //设置t为后台线程
        t.setDaemon(true);
        t.start();

    }

在start之前，设置t为后台进程。

此时，不会打印任何内容。因为主线程快速执行完后，没有其他前台线程，进程结束。

是否存活

使用isAlive判断内核线程是否销毁。

当回调方法执行完毕，线程就销毁了。

Thread对象的生命周期，要比系统内核中的线程要长一些。会出现，Thread对象还在，但是系统内核中的线程已经被销毁了的情况

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("线程开始");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("线程结束");
        });
        t.start();
        System.out.println(t.isAlive());
        Thread.sleep(3000);
        System.out.println(t.isAlive());

    }

true  //线程正在运行
线程开始
线程结束  
false //线程结束了

true和线程开始，这两条日志的打印顺序不一定。因为是并发执行的。

大概率先打印true,因为调用start后，创建新线程也存在一定开销，创建的过程中，主线程就开始打印了。

启动线程

start方法和run方法的区别

1.start方法内部，会调用系统API，在系统内核中创建一个线程。

2.run方法是这个线程的入口方法，描述了这个线程要执行什么内容，会在start创建好线程后自动被调用。

终止\打断一个线程

让一个线程停止运行（销毁）

在Java中，销毁\终止线程的方法，就是想办法让run方法尽快执行结束。

interrupt

1.创建标志位

手动创建一个标志位，作为run执行结束的条件

    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (!isQuit){
                //内部类访问外部类属性
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
            System.out.println("线程工作完毕");
        });

        t.start();//五秒后，设为true
        Thread.sleep(5000);
        isQuit = true;
        System.out.println("设置isQuit为true");
    }

线程工作中
线程工作中
线程工作中
线程工作中
线程工作中
设置isQuit为true
线程工作完毕

isQuit是一个成员变量，不能作为main方法中的局部变量。因为lambda表达式的变脸捕获。lambda表达式里面的代码可以自动捕获到上层作用域当中的局部变量。且这个变量不能进行修改。

变量捕获就是让lambda表达式把当前作用域的变量，在lambda内部复制了一份。外部是否销毁无所谓。

变量捕获只能捕获final或者实际上是final的变量（没有修改）。

2.调用 interrupt() 方法

            while (Thread.currentThread().isInterrupted()){

                //获取当前线程的引用，   //判断标志位是否修改
            }

Thread.currentThread()获取当前线程的实例，得到的就是t

哪个线程调用currentThread这个方法，就会返回哪个线程的对象。

isInterrupted()是Thread内部的标志位

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("线程正在工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(5000);
        System.out.println("让t线程终止");
        t.interrupt();//把标志位设为true
    }
//终止后会继续运行

即使线程内部是阻塞状态，interrupt() 方法也可以进行唤醒。

正常情况下，sleep会休眠到时间才会唤醒。interrupt() 方法可以使sleep内部触发一个异常，从而提前唤醒。

interrupt() 方法唤醒线程后，此时sleep方法抛出异常，同时会自动清除刚才设置的标志位

Java期望，当线程收到信号后，能自己决定需不需要处理。

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("线程正在工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //1.假装没听到，循环继续执行
                    e.printStackTrace();
                    //2.加上break，让线程立即结束
                   //3.把其他代码放在这里执行完再结束。
                    break;

                }
            }
        });
        t.start();
        Thread.sleep(5000);
        System.out.println("让t线程终止");
        t.interrupt();//把标志位设为true

提供了更多的可操作空间。这个前提的通过异常唤醒的，如果没有sleep，就直接结束。

等待一个线程 join()

让一个线程等待另一个线程执行结束后再进行执行。

本质是控制进程结束的顺序。

join方法，实现了线程等待的效果。

在主线程中调用t.join().就是主线程等待t线程先结束

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            for (int i = 0; i < 5; i++) {

                System.out.println("t线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        System.out.println("join等待开始");

        t.join();//让主线程等待t线程执行结束
        //一旦调用join，主线程就会堵塞。一直等到t执行完毕。
        System.out.println("join等待结束");
    }
join等待开始
t线程工作中
t线程工作中
t线程工作中
t线程工作中
t线程工作中
join等待结束

t.join（）的工作过程：

1.如果t线程正在运行中，此时调用join的线程就会堵塞，一直堵塞到t线程执行结束为止。

2.t线程已经结束，就直接返回了，不会堵塞。

3.join默认是死等待，一般都要带有一个超时时间

  t.join(3000);

休眠一个进程sleep

        System.out.println("开始："+System.currentTimeMillis());
        Thread.sleep(1000);
        System.out.println("结束："+System.currentTimeMillis());


开始：1712746732288
结束：1712746733296

sleep休眠的时间并不准确。

系统会按照1000毫秒让线程休眠。时间到了之后，系统会唤醒这个线程，从阻塞状态转化为就绪状态。但是不会立即回到CPU上执行。会存在一个调度开销

二、线程的状态

在Java中，给线程赋予了一些其他状态。
NEW: Thread对象已经存在了，start方法还没有开始调用
TERMINATED: Thread对象还在，但是内核中的线程已经没了
RUNNABLE:就绪状态：（线程已经在CPU上执行了、线程正在排队等待上CPU执行）
TIMED_WAITING:阻塞状态：由于sleep这种固定时间的方式产生的阻塞。
WAINTING:阻塞：由于wait这种不固定时间的方式产生的阻塞。
BLOCKED:阻塞：由于锁竞争导致的阻塞

1、线程安全

1.什么是线程安全

有的代码在单线程环境下，可以正常执行。但是同样的代码，让多个线程去同时执行，就有可能出现BUG。

这类问题就是线程安全问题/线程不安全。

    public static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            //对变量自增50000次
            for (int i = 0; i < 50000; i++) {
                count++;
            }

        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();//没有join的话，线程还没自增完，就会打印count

        System.out.println("count: "+count);
    }

	count: 56269
    count: 54242
    count: 56125

上面的代码在并发执行时，构成了线程安全问题。

实际上c++这行代码，本质上是分为三步进行的。

count++是cpu通过三个指令实现的。

1.load: 把数据从内存，读到cpu寄存器中

2.add：把寄存器中的数据+1

3.sava: 把寄存器中的数据，保存到内存中。

由于线程之间的调度是随机的，会导致在一些顺序下，上面是逻辑出现问题。

在这里插入图片描述

存在无数种情况。可能存在，t1/t2执行1次count++后,另一个执行了N次。由于线程的随机调度，使两个线程执行逻辑的先后顺序，存众多可能。导致结果始终是一个小于10W的随机值

2.产生线程安全问题的原因：

1.操作系统中，线程的调度顺序是随机的（抢占式执行）

2.两个线程，针对同一个变量进行修改

3.修改操作不是原子的

count++就是非原子的操作。加上count++是原子的，就可以解决出现的问题

对count++进行加锁

4.内存可见性问题

5.指令重排序问题。

使用synchronized关键字，来进行加锁。

点击移步博客主页，欢迎光临~

偷cyk的图

翁佳明

关注

8
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
【多线程】Thread的常见属性 | 终止线程 | 等待线程 | 休眠线程 | 线程安全

有的代码在单线程环境下，可以正常执行。但是同样的代码，让多个线程去同时执行，就有可能出现BUG。这类问题就是线程安全问题/线程不安全。//对变量自增50000次i < 50000;});i < 50000;});t1.start();t2.start();t1.join();t2.join();//没有join的话，线程还没自增完，就会打印count上面的代码在并发执行时，构成了线程安全问题。
复制链接

扫一扫