Thread 类的一些基本用法

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量123 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55079859/article/details/126847860
版权

线程的创建

1.创建一个类继承Thread类并重写run方法

class MyTheard extends Thread{
    @Override
    public void run() {
        while(true) {
            System.out.println("hello thread!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyTheard myTheard=new MyTheard();
        myTheard.start();

        while(true){
            System.out.println("hello main!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

2.创建一个类实现Runnable接口，并重写run方法

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyRunnable myRunnable=new MyRunnable();
        Thread thread=new Thread(myRunnable);
        thread.start();

        while(true){
            System.out.println("hello main!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.使用匿名内部类，创建Thread子类，重写run方法

public class Demo3 {
    public static void main(String[] args) {
        Thread thread=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("hello thread!");
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread.start();

        while(true){
            System.out.println("hello main!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4.new一个Runnable实例传给Thread构造方法，并重写run方法

public class Demo4 {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("hello thread!");
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();

        while(true){
            System.out.println("hello main!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.使用lambda表达式创建线程

public class Demo5 {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello thead!");
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread.start();

        while(true){
            System.out.println("hello main!");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

线程的中断

1.手动设计标记位

我们想要中断一个线程，如果那个线程一直在执行，我们可以在run方法中，手动设定一个标记位，假设默认情况为false，然后线程在执行前任务前都要判断标记位，当我们在主线程中更改标记位为true，此时执行的线程被中断，否则继续执行。

public class Demo {
    public static boolean flag=false;//设定标记
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            while (!flag){
                System.out.println("执行线程任务！");
                try {
                    Thread.sleep(1000);//线程每休眠1s就执行一次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();//启动线程
        Thread.sleep(4000);//主线程休眠4s后执行
        flag=true;//更改标记
    }
}

执行结果：

在这里插入图片描述

2.使用Thread对象中得标记位

先调用的是currentThread()方法获取当前线程对象，然后调用该线程对象中的isInterrupted()方法获取标记位，类似我们之前手动设置的flag标记位。线程每次执行任务前都要判断标记位，而我们只需要在main线程中修改标记位就能中断线程的执行。中断线程调用的是interrupted()方法。

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new Thread(()->{
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("线程执行任务！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        Thread.sleep(4000);//主线程休眠
        t1.interrupt();//中断t1线程
    }

}

运行结果：

在这里插入图片描述
和我们预期似乎有差别，线程在执行到了一定时间后，抛出异常后继续执行，并未中断，原因是 因为使用interrupt方法触发中断机制时，如果该线程是Runnable状态则设定标志位，如果该线程是阻塞状态(sleep等)，会抛出异常，虽然此时interrupt仍然会设定标志位，但是sleep、wait等方法会清除这个标记位。所以也就是为什么线程会继续执行。此时如果我们还是非要中断该线程，就得在抛出异常时，在catch代码块内，不仅要抛异常，还需要跳出循环执行的线程任务（break即可）。

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("线程执行任务！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("线程任务结束！");
                    break;
                }
            }
        });
        t1.start();
        Thread.sleep(4000);//主线程休眠
        t1.interrupt();//中断t1线程
    }
}

执行结果：

在这里插入图片描述

3.使用Thread类中的标记位

这是使用Thread类中的静态方法interrupted()也能够访问类中的标记位，而且一般一个程序中只有一个，我们可以用它来作为线程中断的标记位。而修改标记位还是使用interrupt方法来中断线程执行。

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            while (!Thread.interrupted()){
                System.out.println("线程执行任务！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("线程任务结束！");
                    break;
                }
            }
        });
        t1.start();
        Thread.sleep(4000);
        t1.interrupt();//中断t1线程
    }
}

执行结果：

在这里插入图片描述

线程等待

使用join()方法，注意join方法的使用，例如有两个线程，一个线程A，一个线程B，在A中使用B.join()，意思是A线程要等待B线程执行结束后才能执行(A线程阻塞)。同理在B中使用A.join()，意思是B线程要等待A线程执行结束后才能执行(B线程阻塞)。

public class Demo {

    public static final long COUNT=10_000_000_000L;
    
    public static void main(String[] args) {
    
     	long beg=System.currentTimeMillis();
        Thread thread1=new Thread(()->{
            long a=0;
            for (long i = 0; i < COUNT; i++) {
                a++;
            }
        },"这里可以放线程的名字");

        Thread  thread2=new Thread(()->{
            long a=0;
            for (long i = 0; i <COUNT ; i++) {
                a++;
            }
        });

        thread1.start();
        thread2.start();

        try {
            //main线程阻塞,等线程1和线程2执行结束后,main线程才能继续执行
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println("并发执行时间:"+(end-beg)+"ms");
       
    }
 
}

线程休眠

使用sleep(long)方法，会使当前调用的该方法的线程休眠一段时间，这段时间内线程处于阻塞等待状态，该时间是自己设定，等一段时间过后，该线程就会继续执行。

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            while (true){
                System.out.println("线程执行任务！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

获取线程实例

获取当前线程引用使用 Thread.currentThread()方法，在哪个线程内调用，就是获取哪个线程的引用。之前我们用这个对象引用获取isInterrupted()方法判断当前线程是否是处于中断状态。

风吹过你脸颊
关注
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
【Java多线程-创建多线程的基本方式一：继承Thread类】 在Java编程中，多线程是一种并发执行任务的机制，它允许多个任务在同一时间运行，从而提高程序的效率和响应速度。Java提供了多种创建多线程的方式，其中最...
Thread类的用法
m0_63101235的博客
08-14 183
操作系统管理这个线程的PCB的时候是有多个链表的,系统中的PCB分布在就绪队列和堵塞队列（队列中是有链表串联起来的），一个线程在就绪队列中中某一个链表调用了sleep ,则这个PCB就会被移动到堵塞队列中 等到时间一到 就返回就绪队列里面原来的那个位置（且回去了也不一定立马就被执行 得看系统的心情）使用t.join()带参数的意思：就是等到那个时候了 t.join() 线程还没结束 那就不等了,就执行main线程。System.out.println("t 线程执行完了");interrupt()中断。..
Thread中runOnUiThread的简单使用
热门推荐
cf8833的博客
05-17 4万+
1.不能在主线程以外操作UI，android中把耗时的操作都放到子线程里面，主线程又叫UI线程 注意： 不要阻塞主线程（UI线程） 不要从主线程以外的线程更新UI（UI线程） 我们看看这个代码 public class FourActivity extends Activity { private Button btn; private TextView tv; ...
Java的多线程问题
baobaoxiong_123456的博客
05-17 242
什么是多线程线程是依赖于进程而存在的。 A:进程 正在运行的应用程序 B:线程 进程的执行路径，执行单元 多线程的创建方式 通过继承Thread类 通过实现Runnable接口 实现方式一代码如下package com.wy.threadcreate1; /* * 创建线程的第一种方式，继承Thread类 */ public class MyThread extend
实现多线程1--继承Thread类，重写run()方法
m0_51274044的博客
11-19 3564
多线程笔记 1、实现多线程的第一种方法： 继承Thread类，重写run()方法 package com.qinayu.thread; public class TestThread extends Thread{ //继承Thread类 //重写run方法 @Override public void run() { for (int i = 0; i < 20; i++) { //20.for即可打印出for循环快捷键 Syst
关于Thread类中run()方法的一些见解
爱吃袜子的二哈
10-30 2182
先看段代码：public class ThreadDemo { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() {
java线程之用Thread类创建线程的方法
09-05
首先，让我们了解一下`Thread`类的基本构造方法。`Thread`类提供了多个构造函数，允许开发者根据需要定制线程的初始化参数： 1. `public Thread()` - 这个无参构造函数用于创建一个新的线程，没有指定线程的目标、...
worker_thread_class.zip_c# Thread类_event class
09-19
此外，`Thread`类还提供了一个`Abort`方法，可以尝试停止线程，但应谨慎使用，因为它可能导致数据不一致和资源泄露。 接下来，我们谈谈C#中的事件（Event）机制。事件是一种基于发布/订阅模式的通信方式，它允许...
Java并发编程---Thread类
10-30
除了上述介绍的基本方法之外，`Thread`类还提供了一系列其他有用的方法，例如设置线程名称(`setName()`), 获取线程ID(`getId()`), 检查线程是否存活(`isAlive()`), 设置和获取线程优先级(`setPriority()`, `...
Java多线程继承Thread类详解第1/2页
09-02
首先，创建一个新线程的基本步骤是定义一个新的类，该类继承自`Thread`类。在这个子类中，我们需要重写`Thread`类的`run()`方法，`run()`方法包含线程的主要逻辑。例如： ```java public class MyThread extends ...
QThread之重写run() 实现线程与业务解耦
百里杨的博客
05-24 1964
一、线程的一般实现形式 Qt中线程类QThread有2种使用方式。 1.继承自QThread，重写run() class MyThread : public QThread { Q_OBJECT protected: virtual void run() override { ... } }; 我们一般在run()中加个死循环，不停处理业务或者调用相关的方法。这样的话，我们的业务逻辑与线程紧密耦合在一起。 适用场景： 用于一直不停处理业务，而不是处理完一单业务后，就可以休眠的这
创建Thread对象时，当Runnable的run撞上Thread的run时谁会让步？
春暖花开
08-24 1628
当一个Java的Thread对象既传入了一个Runnable对象作为参数，同时又重写了Thread的run方法，究竟哪个run方法会得到执行。针对这个问题，本文通过分析源码，剖析原理，做出了完美的解答。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1124
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 179
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 934
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 351
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 968
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1223
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 483
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
Java Thread类详解：构造器、方法与优先级
首先，让我们了解一下Thread类的基本构造器： 1. **Thread()**: 无参构造器，用于创建一个新的线程对象，但没有指定线程名称。当子类没有提供自定义构造器时，系统默认使用此构造器，并通过super()调用父类Thread的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值