多线程的创建,复习匿名内部类,Thread的一些方法,以及lambda的变量捕捉,join用法(二)

简介: 多线程的创建,复习匿名内部类,Thread的一些方法,以及lambda的变量捕捉,join用法

、💙  

Thread的方法💙

(一个线程的run方法执行完毕,就算终止了。此时的终止此处线程,就是要想办法让run尽快执行完毕(正常不会出现run没执行完毕,突然就没了的情况)

(sleep相当于是停一会,不是说停止了)

1.程序猿们手动设置标志位,如

public static voolean isQuit=false;(写成成员变量,不会触发变量捕捉,而是内部类来访问成员变量, 看下面这个图,代码在后面,执行完isQuit=true; 线程就终止了,同时main也走完了。

public  class  Demo {
    public static boolean isQuit=false;
        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t=new Thread(()->{
                    int m =0;
                    while(!isQuit){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            },"myThread");
            t.start();
            while (n<3) {
                System.out.println("love");
                n++;
                Thread.sleep(1000);
            }
            isQuit=true;          //手动终止
        }
    }

但是我们来看下面这个图,为什么我这样放进方法里面不可以呢?——这就源于我们lambda表达式变量捕捉机制~

lambda可以捕获外界变量,这样lambda表达式执行的时机是更靠后的,这就导致,后续真正执行lambda时候,局部变量isQuit是否可能已经被销毁了呢?

这种情况是客观存在的,让lambda去访问一个已经被销毁的变量,很明显是不合适的,lambda引入了变量捕获这样的机制~,lambda去访问一个已经被销毁的变量,但明显是不合适的,lambda引入了变量捕获这样的机制~,lambda内部看起来是直接访问外部的变量,其实本质是把外部变量给复制了一份,到lambda里面(这样就可以解决刚才的生命周期问题了)(但是捕获变量有限制的,要求是be final(如同final,就是一个变量,我们后续没有修改他的操作) or effectively final(事实上的最终值 final修饰)

2.直接用Thread 类,给我们提供了现成标志位,不用手动, 🐶

while(!Thread.currentThread().isInterrupted())

Thread.currentThread():的含义获取当前线程的对象Thread,提供静态方法,currentThread在哪个线程调动这个方法,就能够获取到哪个线程的引用(相当于就是t,但是不可以写t,写t是报错的)

isInterrupted()

对象内部,提供了一个标志位(boolean类型的)

true:结束

false:不结束

我们看上面的图能发现,为啥还会有异常呢?🐹,原因就是一个线程kennel正在运行,也可能处于sleep状态,如果线程sleep的过程中,是否应该把他唤醒你?

当然了,肯定要把他唤醒,但是sleep在唤醒的同时也会自动清除前面设置的标志位,给程序猿们留下操作空间,此时要是想让线程结束,则catch之后加一个break;

sleep唤醒之后,程序猿们一般有以下几种操作方式:

1.立即停下来,立即结束线程

2.忽略终止请求,继续循环(不写break)

3.继续做点别的事情,过一会再结束线程(catch之后执行别的逻辑,最后break;)

 

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t= new Thread(()->{
                    int m =0;
                    while(!Thread.currentThread().isInterrupted()){
                        System.out.println("hello world");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            break;
                        }
                    }
            },"myThread");
            t.start();
            while (n<3) {
                System.out.println("love");
                n++;
                Thread.sleep(1000);
            }
           t.interrupt();
        }
    }

四、💗

等待线程——join

多个线程是并发执行的,具体的执行过程,都是由操作系统复制调度的!!!,操作系统的调度线程“随机的”(当然,是我们无法确定他的先后顺序)

等待线程就是一种规划线程结束顺序的手段~ A,B两个线程,希望B先结束,A后结束,此时就可以,让A线程调用B.join方法(去等待B)

此时B线程还没结束完,A线程就会进入阻塞状态,相当于给B留下了空间,B执行完毕之后,A再从阻塞状态中恢复回来,并且继续往后执行。,如果A执行到B.join的时候,B已经执行完,那么A就不用阻塞了,直接往下执行即可,如下图,他是等待,先把t这个线程走完了,再去走下面的main.

阻塞->该代码暂时不继续执行(该进程暂时不去cpu参与调度)sleep也能让该线程阻塞,但是是有时间限制的

join是死等,知道你完事,不然他不会开始(不推荐) 产生一个新的join(里面填写时间)最大等待时间。只要我时间到了,不管你来不来,我都走了(更推荐使用,这种时间版本,留有余地。)

可以被interrupt唤醒的等待操作:

1.join

2.sleep

3.wait

需要的自己拿着用呗

public  class  Demo {
        public static void main(String[] args) throws InterruptedException {
            int n =0;
            Thread t= new Thread(()->{
                    int m =0;
                    while(m<5){
                        System.out.println("hello world");
                        m++;
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            },"myThread");
            t.start();
            t.join(3000);
            while (n<3) {
                System.out.println("love");
                n++;
                Thread.sleep(1000);
            }
        }
    }
相关文章
|
9天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
11 3
|
9天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
10 2
|
9天前
|
Java
在Java多线程编程中,实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中,实现Runnable接口通常优于继承Thread类。原因包括:1) Java只支持单继承,实现接口不受此限制;2) Runnable接口便于代码复用和线程池管理;3) 分离任务与线程,提高灵活性。因此,实现Runnable接口是更佳选择。
22 2
|
9天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
19 2
|
9天前
|
安全 Java
Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧
【10月更文挑战第20天】Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧,包括避免在循环外调用wait()、优先使用notifyAll()、确保线程安全及处理InterruptedException等,帮助读者更好地掌握这些方法的应用。
11 1
|
9天前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
19 1
|
25天前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
38 1
C++ 多线程之初识多线程
|
9天前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
21 1
|
9天前
|
Java
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件成立时被唤醒,从而有效解决数据一致性和同步问题。本文通过对比其他通信机制,展示了 `wait()` 和 `notify()` 的优势,并通过生产者-消费者模型的示例代码,详细说明了其使用方法和重要性。
17 1
|
25天前
|
存储 前端开发 C++
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
42 6