Java 多线程（一）—— 线程的创建与属性

🕗 发布于 2024-10-15 01:44 java 线程

线程的创建

方式一：继承 Thread 类，重写 run 方法

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello Thread");
    }
}

方式二：实现 Runnnable 接口：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello runnable");
    }
}

方式三：使用匿名内部类：

   Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("hello Thread");;
            }
        };
        
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello runnable");
            }
        };
        
        Thread t2 = new Thread(r);

方式四：使用 Lambda 表达式创建 Thread 对象。

        Thread t3 = new Thread(() -> {
            System.out.println("hello Thread t3"); 
        });

上述方式我们只是创建了 Thread 对象，并没有真正创建线程，我们需要使用.start() 方法才能真正创建线程出来，我们来看一下线程的并发执行：

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true) {
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();

        while(true) {
            System.out.println("hello Main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

在这里插入图片描述

你会发现这里会循环打印“hello Thread” 和 “hello Main”，但是这两个顺序是不确定的，也就说明线程的调度是随机的，抢占式执行的

如果我们没有使用 .start() 而是直接使用run() 方法，那结果会如何？

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true) {
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.run();

        while(true) {
            System.out.println("hello Main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

在这里插入图片描述

你会发现会一直打印“hello Thread”，为什么？
因为此时直接使用.run() 方法是不会在进程中创建线程的，而是像普通的类调用自己的方法一样，由于是在主线程中直接调用 run 方法，所以上面的打印是在主线程中进行的，所以后面的 hello main 无法打印，因为前面已经发生死循环了。

这里简单说明一下，在Java 中，使用 main 方法就会自动开启主线程（你也可以叫做 Main 线程），所以在没有学习多线程之前，我们编写的代码都是单线程的。

run() 方法是线程的入口方法，在线程创建好之后，就会自动调用这个方法，不需要我们手动去调用
run() 方法相当于回调函数。

start() 方法一个线程对象只能使用一次

查看线程信息的工具：jconsole

首先打开自己的 jdk 目录，点击 bin 然后找到 jconsole

一般在C:\Program Files\jdk-17\bin 下

在这里插入图片描述

然后我们在 IDEA 创建线程：

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true) {
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();

        while(true) {
            System.out.println("hello Main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

在这里插入图片描述

进行本地连接：

选择不安全连接：

在这里插入图片描述

点击线程：
在这里插入图片描述

之后我们就可以看到下面的线程调用栈了：
在这里插入图片描述

在这里我们可以看到主线程 main 还有 Thread-0 线程，还有其他一些线程是 JVM 自带的线程。

Thread 类的构造方法

Thread()

无参构造方法，在上面已经使用过。

Thread(Runnable target)

传入 Runnable 对象来创建线程，上面也使用过

Thread(String name)

给线程命名，这是为了我们后续如果要查看线程的信息的时候，一个有意义的名字可以让我们更好地在 Jconsole 找到。

Thread(Runnable target, String name)

和 Thread(String name) 异曲同工

Thread(ThreadGroup group, Runnable target)

线程可以被用来分组管理，分好的组为线程组。

线程的属性

在这里插入图片描述

前台线程与后台线程

前台线程控制着整个进程的生命周期，当所有的前台线程都结束了，整个Java进程才会结束。

后台线程又被称为守护线程，后台线程主要由JVM产生的，例如垃圾回收。

我们自己创建的线程都是属于前台线程，当然我们也可以通过setDaemon() 方法来设置，daemon 有守护的意思，所以我们可以传入 true 来设置后台进程，但是这个方法必须放在start()之前

        Thread t = new Thread(() -> {
            while(true) {
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.setDaemon(true);
        t.start();

线程的中断

在上面的表格中我们看到一个方法isInterruprted() ，这个方法是用来判断某个线程是否中断了，这里的中断实际上就是终止的意思，也就是不会再恢复了，即线程终止。

模拟实现线程终止

我们可以通过一个标志位来实现线程的终止。

public class Demo1 {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           while(flag) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });

        t.start();
        flag = false;

        while(true) {
            System.out.println("hello Main");
            Thread.sleep(1000);
        }
    }
}

在这里插入图片描述

通过外部类的成员来控制线程，会出发线程的内部类访问外部类成员的语法

如果我们使用的是局部变量：会怎么样？

在这里插入图片描述

你会发现这是不允许的，为什么？

lambda 表达式中的是回调函数，线程创建之后执行这个回调函数是很久之后的事情了，就有可能 main 线程结束了，随之 flag 这个变量也别销毁了，那么线程 t 在后面就无法获取到 flag 这个数值了。

为了解决这个问题，Java 使用变量捕获的方法，就是把被捕获的变量拷贝一份到 lambda 里面，这样外面的线程是否销毁就不会影响 lambda 里面的执行了。因为是拷贝，所以意味着这个变量是不适合进行修改的，你在另一个线程进行修改是不会影响到另一个线程已经拷贝好的数据的。

所以Java 这边就不允许你进行修改，所以这种变量天生自带 final 属性或者事实 final 属性，什么叫做事实 final，就是这个变量没有被 final 修饰，但是这个变量没有进行过修改，着就是事实 final 属性。

    public static void main(String[] args) throws InterruptedException {
        boolean flag = true;
        Thread t = new Thread(() -> {
           while(flag) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });

        t.start();

        while(true) {
            System.out.println("hello Main");
            Thread.sleep(1000);
        }
    }

像上面这种使用及局部变量的，会触发线程的“捕获变量”的语法

interrupt() 与 isInterrupted()

我们可以自己手动终止线程。

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           while(!Thread.currentThread().isInterrupted()) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });

        t.start();
        t.interrupt();
    }

当我们运行完之后：
在这里插入图片描述
为什么会抛出异常？

因为我们在线程中写了一个sleep 方法，当你终止线程的时候， sleep 可能还没执行到 1s，就被interrupt 终止了，就会抛出 InterruptedException e 异常。

如何解决这个异常？我们可以选择不抛异常出来，当外面捕获到异常的时候，可以选择 break 这个循环。

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           while(!Thread.currentThread().isInterrupted()) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   break;
               }
           }
        });

        t.start();
        t.interrupt();
    }

在这里插入图片描述

我们明明在t.start() 后面使用了t.interrupt() 终止了线程，可是为什么还会打印出一个“hello Thread" ?
t.interrupt() 是在方法 main 线程里的，由于线程的调度是随机的，所以 main 线程和 t 线程都是随机调度的，上面的运行结果就是属于 t 线程先执行了，然后才执行到 main 线程里的终止代码。

当然你也可以选择不 break 掉，你可以选择什么都不做:

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           while(!Thread.currentThread().isInterrupted()) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {

               }
           }
        });

        t.start();

        Thread.sleep(2000);
        t.interrupt();
    }

在这里插入图片描述

你会发现居然会一直打印”hello Thread"，为什么？
原因就在 sleep 中，当线程中有 sleep 方法的时候，如果你进行终止线程，那么 sleep 大概率会因为没有到达 1s 的设定休眠时间而被唤醒，这时候 sleep 会再次把线程的终止状态修改为执行状态，也就是把线程的isInterrupted() 属性由 true 修改回 false

Java这样实现，有什么好处？
首先线程可以有三种选择可以执行，第一种就是上面的继续执行，无视终止指令。
第二种就是在捕获到异常后，可以在处理代码部分写上一些代码，获取阶段性的结果，也就是如果线程终止了我们可以得到线程终止之后的预期结果，而不是零零散散的随机的结果。
第三种就是直接终止线程，这种我们在 catch 代码中抛出异常或者如果是循环的话直接写上 break 即可。

补充说明：Thread.currentThread().isInterrupted() 为什么要这样写？
因为 lambda 的定义是在 Thread 实例化之前的，毕竟我们知道要先重写完 run 方法才能进行对象的实例化，因此 lambda 表达式中是不知道 t 的存在的，所以我们要通过Thread.currentThread() 方法来获取当前的线程对象
currentThread() 方法是静态方法，所以直接使用类名.方法来调用即可。

线程存活

线程的销毁不意味着线程对象的销毁。

我们在终止完线程之后，还是可以通过线程对象来获取线程的属性的：

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
           while(!Thread.currentThread().isInterrupted()) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                    break;
               }
           }
        },"test");

        t.start();

        Thread.sleep(2000);
        t.interrupt();

        System.out.println(t.getName());
    }

在这里插入图片描述

原因：线程的销毁工作是由操作系统完成的，而对象的销毁是由 JVM 的 GC（垃圾回收机制）实现的，在Java中线程的销毁并不意味着线程对象也被销毁了。

线程是否存活，简单的理解，就是run方法是否运性结束了

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("hello Thread");
            }
        });

        t.start();

        Thread.sleep(1000);
        System.out.println(t.isAlive());
    }

在这里插入图片描述

为什么要加上 sleep ，因为要保证 t 线程结束了，再进行打印，因为线程的调度是随机的。

原文地址：https://blog.csdn.net/liwuqianhzc/article/details/142886475

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：大厂面试真题-说一说CyclicBarrier、CountDownLatch和Semaphore
下一篇：用双踪示波器测量两个波形间的相位差的理论计算值怎么算

一文了解如何应对生成式AI和大模型应用带来的存储挑战
技术的发展正在推动着存储技术的变革，随着QLC、CXL和HBM等先进技术的不断突破和发展，生成式AI和大模型应用面临的存储墙问题将迎刃而解！生成式AI和各种大模型应用，对算力提出了更高的要求，CPU+
阅读更多2024-10-15
Excel：vba实现合并工作簿中的表
A、B、C这三个工作簿的数据都在sheet1，表头一样。
阅读更多2024-10-15
增强对象智能：谷歌开源的XR-Objects项目简介
根据用途的不同，整个系统被划分为四大主要类别：信息查询、对比分析、内容分享以及注释添加。每个类别之下又有多种具体的功能可供选择。总之，通过结合最新的计算机视觉技术和人工智能算法，谷歌成功打造出了一个极
阅读更多2024-10-15
MambaVision原理和源码调测
后面可以看到代码实现也是按照N/2写的。
阅读更多2024-10-15
Bluetooth Channel Sounding中关于CS Step及Phase Based Ranging相应Mode介绍
支持BLE CS的设备，必须要支持此模式，主要用于测量获得BLE CS双方的存在频率偏差。具体来说，是BLS CS中的initiator设备用此模式获得reflector设备与自身的频率偏差。获得该频
阅读更多2024-10-15
速卖通商品详情接口技术解析及Python代码示例
速卖通（AliExpress）作为全球知名的跨境电商平台，其开放平台提供了丰富的API接口，允许开发者集成速卖通的各项功能，实现商品搜索、详情查询、订单管理等一系列操作。本文将重点介绍如何使用速卖通商
阅读更多2024-10-15
【Kubernets】容器网络基础二：通讲CNI（Container Network Interface）容器网络接口实现方案
Macvlan和Ipvlan都是强大的 Linux 内核特性，能够为容器和虚拟机提供高效的网络连接。选择哪种技术取决于具体的网络需求和应用场景。如果你需要每个虚拟网络接口有独立的 MAC 地址，可以选
阅读更多2024-10-15
数据结构：双向带头链表
双向带头链表简易代码
阅读更多2024-10-15
Spring webflux
WebFlux的确通过线程池和多路复用的方式来处理请求，避免了传统每个请求都创建新线程的做法。虽然维护的线程数量是固定的，但由于采用了非阻塞和异步事件驱动的机制，线程并不会因为等待 I/O 而被阻塞，
阅读更多2024-10-15
Python 中 NameError 全局名称未定义
NameError: name 'x' is not defined 是 Python 中常见的错误之一，通常表示你尝试访问一个尚未定义的变量或函数。特别是全局名称未定义时，意味着你在使用某个
阅读更多2024-10-15

Java 多线程（一）—— 线程的创建与属性

线程的创建

查看线程信息的工具：jconsole

Thread 类的构造方法

Thread()

Thread(Runnable target)

Thread(String name)

Thread(Runnable target, String name)

Thread(ThreadGroup group, Runnable target)

线程的属性

前台线程与后台线程

线程的中断

模拟实现线程终止

interrupt() 与 isInterrupted()

线程存活

相关文章