Java多线程-----Thread类的基本用法，线程的状态及其转化 ✧*(ˊᗜˋ*) ✧*

最新推荐文章于 2024-07-18 16:29:57 发布
最新推荐文章于 2024-07-18 16:29:57 发布
阅读量717 收藏 44
点赞数 59
分类专栏： Java多线程 文章标签： java 开发语言 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79862386/article/details/140515959
版权

😖一.开启一个线程start()：

run()和start()的区别:

start()：用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。

run()：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

①.通过start()启动线程：

class MyThread2 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("what can I say");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        MyThread2 t = new MyThread2();
        //启动t线程
        t.start();
        //线程之间并发执行，主线程继续往下执行代码
        while(true){
            System.out.println("Mamba Out");
            Thread.sleep(1000);
        }
    }
}

运行结果（start是真正启动一个线程，所以两个线程并发执行）：

②.通过类来调用run（）方法：

class MyThread2 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("what can I say");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        MyThread2 t = new MyThread2();
        //通过类的实例来调用run()方法
        t.run();
        //线程之间并发执行，主线程继续往下执行代码
        while(true){
            System.out.println("Mamba Out");
            Thread.sleep(1000);
        }
    }
}

运行结果（可以看到这其实就是调用一个普通的方法）：

run() 和 start()的区别理解二：

1、线程中的start()方法和run()方法的主要区别在于，当程序调用start()方法，将会创建一个新线程去执行run()方法中的代码。但是如果直接调用run()方法的话，会直接在当前线程中执行run()中的代码，注意，这里不会创建新线程。这样run()就像一个普通方法一样。

2、另外当一个线程启动之后，不能重复调用start()，否则会报IllegalStateException异常。但是可以重复调用run()方法。

总结起来就是run()就是一个普通的方法，而start()会创建一个新线程去执行run()的代码。

总结来说就是：

1、start方法用来启动相应的线程；

2、run方法只是thread的一个普通方法，在主线程里执行；

3、需要并行处理的代码放在run方法中，start方法启动线程后自动调用run方法；

4、run方法必须是public的访问权限，返回类型为void。

如果直接调用线程类的run()方法，这会被当做一个普通的函数调用，程序中仍然只有主线程这一个线程，也就是说，start()方法能够异步地调用run()方法，但是直接调用run()方法却是同步的，因此也就无法达到多线程的目的。

​ 只有通过调用线程类的start()方法才能真正达到多线程的目的。

通过作用功能和运行结果的角度分析：

作用功能不同：

  • a.run 方法的作用时描述线程具体要执行的任务

  • b.start 方法的作用是真正去申请一个系统线程

运行结果不同：

  • a.run 方法是一个类的普通方法，主动调用和调用普通方法一样，会顺序执行一次；

  • b.start 方法调用执行后，start方法内部会调用Java本地方法（封装了对系统底层的调用）真正的启动一个线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段

start方法的执行一般是比较快的（创建线程，比较轻量），一旦start执行完毕后，新线程就会开始执行，调用start的线程，也会继续执行（main）。同时，调用start方法，不一定非得是main线程，任何的线程都可以创建其他线程。如果资源充裕，就可以任意的创建线程（线程也不是越多越好，同时，值得注意的是，由于线程的创建是有开销的，当主线程中还有要执行的代码时，一般是主线程的代码先执行（这个创建线程的时间是很短的）一部分。

😋二.线程的终止：

1.使⽤⾃定义的变量来作为标志位:

public class demo1 {
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while(!isQuit){
               System.out.println("hello thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println("t 线程结束");
        });
        t.start();

        Thread.sleep(2000);
        //修改isQuit 变量，就能够影响到t 线程的结束了
        System.out.println("main线程尝试终止t线程");
        isQuit = true;
    }
}

运行结果：

2.Thread.currentThread().isInterrupted() 代替⾃定义标志位

public class demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            //t.isInterrupted();
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                   //throw new RuntimeException(e);
                    System.out.println("执行到catch操作");
                }
            }
        });
        //开启线程
        t.start();

        Thread.sleep(3000);
        System.out.println("尝试终止线程");
        t.interrupt();
    }
}

运行结果：

小结一下就是：①.Interrupt方法能够设置标志位,也能够唤醒sleep等阻塞方法

                         ②.sleep被唤醒后，又能清空标志位

🧐三.线程的休眠（sleep）:

这是我们⽐较熟悉⼀组⽅法，有⼀点要记得，因为线程的调度是不可控的，所以，这个⽅法只能保证 实际休眠时间是⼤于等于参数设置的休眠时间的。

常用方法：

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(System.currentTimeMillis());
        Thread.sleep(1000);
        System.out.println(System.currentTimeMillis());
    }
}

运行结果：

😀四.线程的等待join():

有时，我们需要等待⼀个线程完成它的⼯作后，才能进⾏⾃⼰的下⼀步⼯作

常用方法：

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            for(int i = 0;i < 3;i++){
                System.out.println("Hello World~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //开启t线程并让主线程等待t线程结束
        t.start();
        t.join();

        for(int i = 0;i < 3;i++){
            System.out.println("I am main Thread");
        }
    }
}

运行结果：

谁调用，谁就是被等待的，在哪里中调用，就是再哪里等待。这里再主线程中调用t.join(),所以是主线程等待t线程结束，而t线程是被等待的。可以看到直到t线程执行完成后，主线程才结束


练习一：

  1. 给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
  2. 实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
  3. 其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
  4. 最终再汇总两个和, 进行相加
  5. 记录程序的执行时间.

代码详解：

import java.util.*;
public class Demo1 {
    public static long sum1 = 0L;
    public static long sum2 = 0L;
    public static void main(String[] args) throws IOException, InterruptedException {
        long startTime = System.currentTimeMillis();//记录运行的起始时间
        int[] nums = new int[10000000];
        Random random = new Random();
        for(int i = 0;i < nums.length;i++){
            nums[i] = (random.nextInt(100) + 1);//1 ~ 100
        }
        //创建线程
        Thread t1 = new Thread(()->{
            for(int i = 0;i < nums.length;i += 2){
                sum1 += nums[i];
            }
            System.out.println("线程t1，偶数下标的总和是：" + sum1);
        });

        Thread t2 = new Thread(()->{
            for(int i = 1;i < nums.length;i += 2){
                sum2 += nums[i];
            }
            System.out.println("线程t2，奇数下标的总和是：" + sum2);
        });
        //开启线程
        t1.start();
        t1.join();
        t2.start();
        t2.join();

        long endTime = System.currentTimeMillis();//记录运行的终止时间

        System.out.println("这1000w个随机数的和是: " + (sum1 + sum2));
        System.out.println("一共的运行时间是: " + (endTime - startTime));
    }
}

 运行结果：

练习二：

有20个线程，需要同时启动。

每个线程按0-19的序号打印，如第一个线程需要打印0

请设计代码，在main主线程中，等待所有子线程执行完后，再打印 ok

代码 详解：

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[20];
        for(int i=0; i<20; i++){
            final int n = i;
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {//内部类使用外部的变量，必须是final修饰
                    System.out.println(n);
                }
            });
        }
        for(Thread t : threads){
            t.start();
        }
        for(Thread t : threads){//同时执行20个线程，再等待所有线程执行完毕
            t.join();
        }
        System.out.println("OK");
    }

}

运行结果（结果1~19，这里只展示部分,线程并发执行，抢占到CPU的运行权时期不同，造成的随机打印的结果）：

 

😚五.获取一个线程的实例：

常用方法：

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            //获取当前线程的实例
            Thread cur = Thread.currentThread();
            for(int i = 0;i < 3;i++){
                System.out.println(cur.getName()+" :Hello World~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.setName("线程一");
        //开启t线程并让主线程等待t线程结束
        t.start();

    }
}

运行结果：

😆程的六个状态：

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  3. 阻塞(BLOCKED)：表示线程阻塞于锁。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  6. 终止(TERMINATED)：表示该线程已经执行完毕。

线程状态之间的转化： 

结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！

IYF.星辰
关注
  • 59
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 44
    评论
专栏目录
Java多线程-创建多线程的基本方式二：实现Runnable接口
01-25
- **启动线程**：创建`Thread`对象，将`Runnable`实现类的实例作为参数传递给`Thread`的构造函数，然后调用`Thread`对象的`start()`方法启动线程，执行`run()`方法。 2. **示例代码** ```java // 实现Runnable...
第-章-JAVA多线程优秀文档.pptx
12-01
本文档将详细介绍 JAVA 多线程的概念、特点、创建方式、线程生命周期、同步机制、线程通信等知识点，并通过实例分析和代码示例来深入讲解 JAVA 多线程的应用场景和实现方法。 一、JAVA 多线程概念 在 Java 中，...
【Java】实验七 多线程
2201_75406816的博客
07-13 871
实验七 多线程
多线程（JavaEE初阶系列7）
weixin_61599986的博客
08-01 705
常见的锁策略你都知道哪些呢？
多线程（JavaEE初阶系列4）
weixin_61599986的博客
07-25 558
单例模式与阻塞式队列到底是什么呢？
多线程（JavaEE初阶系列6）
weixin_61599986的博客
07-28 538
手动实现一个线程池。
WHUT-java多线程实验-第三周-文件上传和下载.zip
01-16
在“WHUT-java多线程实验-第三周-文件上传和下载.zip”这个实验中，我们将重点探讨如何在多线程环境中实现文件的上传和下载功能。这个实验基于IntelliJ IDEA开发环境，它是一个流行的Java集成开发环境，提供了丰富的...
WHUT-java多线程实验-第四周-GUI.zip
01-16
1. **Java多线程**：Java通过`Thread`类和`Runnable`接口支持多线程编程。创建新线程有两种主要方式：继承`Thread`类或实现`Runnable`接口。在Java中，主线程负责执行程序的主要逻辑，而其他线程可以并行执行特定...
Java多线程-线程安全问题练习题
01-30
在Java多线程编程中，线程安全问题是非常关键的概念，它涉及到多个线程访问共享资源时可能出现的数据不一致或异常情况。本题主要通过两个练习题来加深对线程安全的理解。 ### 练习题1：新年倒计时 #### 题目描述 ...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 835
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 905
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1026
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 835
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java 线程池详解
qq_41591215的博客
07-13 966
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 162
【JAVA】相关程序组件
【Java算法】前缀和 下
最新发布
2302_79806056的博客
07-18 882
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 501
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 520
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 44
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值