Thread 类的基本用法

已于 2023-03-14 23:47:06 修改
阅读量126 收藏
点赞数
文章标签： java
于 2023-03-14 23:25:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53190275/article/details/129542529
版权
本文介绍了Java中线程的创建方法，包括继承Thread、实现Runnable接口以及使用匿名内部类和lambda表达式。同时，详细讨论了线程的中断机制，通过设置结束标志位和调用interrupt()方法。还提到了线程等待（join）和休眠（sleep）的方法，以及如何获取当前线程实例。
摘要由CSDN通过智能技术生成

目录

1.线程创建

1.继承 Thread, 重写 run

2.实现 Runnable, 重写 run

3.继承 Thread, 重写 run, 使用匿名内部类

4.实现 Runnable, 重写 run, 使用匿名内部类

5.使用 lambda 表达式

2.线程中断

2.1给线程中设定一个结束标志位

2.2调用 interrupt() 方法来通知

3.线程等待

4.线程休眠

5.获取线程实例

1.线程创建

1.继承 Thread, 重写 run

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

2.实现 Runnable, 重写 run

class MyRunnable implements Runnable{

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

3.继承 Thread, 重写 run, 使用匿名内部类

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

4.实现 Runnable, 重写 run, 使用匿名内部类

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

5.使用 lambda 表达式

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

2.线程中断

让一个线程停下来,线程的终止

本质上,线程终止办法就一种,让线程的入口方法执行完毕

2.1给线程中设定一个结束标志位

while(true){
           ...
        }

死循环,导致入口方法无法执行完毕

解决方法

blic static boolean isQuit=false;
public static void main(String[] args) {
    Thread t=new Thread( ()->{
        while(!isQuit){
            System.out.println("hello t");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();//打印当前异常位置的调用栈
            }
        }
        System.out.println("t 线程终止");
    });

    t.start();
    //在主线程中,修改isQuit
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    isQuit=true;
}

 

2.2调用 interrupt() 方法来通知

interrupt方法的作用:

1.设置标志位为true

2.如果该线程正在阻塞中(比如在执行sleep)

 

public static void main(String[] args) {
    Thread t=new Thread(() ->{
        //currentThread是获取到当前线程实例
        //currentThread得到的对象是t
        //isInterrupted是t对象里自带的一个标志位
        while(!Thread.currentThread().isInterrupted()){
            System.out.println("hello t");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
                //如果要结束循环,要在catch中加break
            }
        }
    });

    t.start();

    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();

    }
    //把t内部的标志位设置为true
    t.interrupt();
}

 

此时会把阻塞状态唤醒

通过抛出异常的方法让sleep立即结束

当sleep被唤醒时,sleep会自动把isInterrupted标志位给清空(true->false)

观察标志位是否清除:

如果sleep执行时,标志位为false,sleep正常休眠

如果标志位为true,无论sleep刚执行或执行一半:

1.立刻抛出异常

2.清空标志位为false

下次循环到sleep,由于标志位本身是false,就什么都不干

多线程执行顺序:

每个线程都是独立执行,执行到start方法,代码兵分两路,主线程继续执行,新线程进入到run方法执行,主线程执行完interrupt,继续往后执行,不会再到interrupt

interrupt只是通知,不是"命令",是否结束由代码来灵活控制

3.线程等待

线程之间并发执行,操作系统对线程的调度,无法确定哪个线程先执行结束

用线程等待可以规定结束顺序:如果t1线程中,调用t2.join,是让t1线程等待t2结束

Thread t=new Thread(()->{
    System.out.println("t");
});
t.start();
t.join();
//在main中调用t.join,是让main线程等待t先结束,在往下执行
//在t.join执行,如果t线程还没结束,main线程会阻塞等待
System.out.println("main");

1.main线程调用tjoin的时候,如果t还执行

此时main线程阻塞,再到t执行完毕(t的run执行完了),main才从阻塞中解除,才执行

2.main线程调用t.join的时候,如果t结束

此时join不会阻塞,会立即往下执行

都保证t是先结束的

join还有一个有参的版本,填写一个参数,作为超时时间,最大等待时间

如果等待时间到达上限,还没等待,就不等了

4.线程休眠

方法

说明

public static void sleep(long millis) throws InterruptedException

休眠当前线程 millis

毫秒

public static void sleep(long millis, int nanos) throws

InterruptedException

可以更高精度的休眠

 try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
                //如果要结束循环,要在catch中加break
            }

5.获取线程实例

方法

说明

public static Thread currentThread();

返回当前线程对象的引用

 

public static void main(String[] args) {
Thread thread = Thread.currentThread();
    System.out.println(thread.getName());
}

沐晴0128
关注
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1928
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
java中Thread用法
热门推荐
初心
05-13 1万+
一.线程的状态二.上下文切换三.Thread类中的方法线程的状态　在正式学习Thread类中的具体方法之前，我们先来了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。　　线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、
Thread类的基本用法1
r798303142b的专栏
06-02 613
一、             Thread类的基本用法 通过System.Threading.Thread类可以开始新的线程，并在线程堆栈中运行静态或实例方法。可以通过Thread类的的构造方法传递一个无参数，并且不返回值（返回void）的委托(ThreadStart)，这个委托的定义如下： [ComVisibleAttribute(true)] public delegate
Thread类的使用
bobolan
10-17 245
一.线程的状态 在学习Thread类中的具体方法之前，先了解一下线程有哪些状态，这个将会有助于后面对Thread类中的方法的理解。 线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。 当需要新起一个线程来执行某个子任务时...
Thread的基本用法
m0_64318128的博客
11-29 3020
Thread类中一些常用方法和属性的使用和特点
Java多线程-创建多线程的基本方式一：继承Thread类
01-19
【Java多线程-创建多线程的基本方式一：继承Thread类】 在Java编程中，多线程是一种并发执行任务的机制，它允许多个任务在同一时间运行，从而提高程序的效率和响应速度。Java提供了多种创建多线程的方式，其中最...
Thread 类及常见方法
weixin_58697177的博客
07-21 1261
系统对于线程的调度是随机的，假设我们的机器上面存在很多的进程和线程，此时 CPU 调度一圈，消耗的时间可能就比较长，此时就可能导致某个线程隔了很久也没有调度上去，这个可能大多数人都遇到过这种情况：某些时候，电脑卡了，点击某个窗口，提示“未响应”，让我们选择等待还是结束进程。此时会出现这样的提示信息，意思是 isQuit 这个变量不是常量或者“实际常量”，常量就是 final 修饰的，“实际常量”是没有final修饰，但是也没有其他代码尝试修改的变量，但是我们在下面对 isQuit 进行了修改，所以不行。
C#winform程序Thread(线程)和ThreadPool(线程池)的基本用法
11-17
本文将详细介绍C#中Thread和ThreadPool的基本用法及其应用场景。 ## 1. 线程（Thread） ### 1.1 创建线程 创建线程主要通过以下两种方式： - `System.Threading.Thread` 类：通过实例化该类并调用其`Start()`...
Thread类基本用法
最新发布
ling_zu_qi的博客
03-29 734
Thread类基本用法
Thread类的基本用法
m0_67703342的博客
07-28 177
java多线程初阶
Thread类常用方法
weixin_30302609的博客
03-03 314
Thread类构造方法： 1.Thread（）； 2.Thread（String name）； 3.Thread（Runable r）； 4.Thread（Runable r, String name）； [java]view plaincopy publicclassTest{ publicstaticvoidm...
Thread的使用
Yan1less的小窝
03-14 256
本文只是初步介绍java中的线程，仅了解其重要方法的用法和需要注意的点。 join()：比如在A线程中调用B.join()。那么在B线程执行完之前A会一直阻塞；底层是用wait实现，所以会释放锁 wait()：阻塞线程 notify()：唤醒线程，这两个方法会成对出现，这两个方法的使用要在锁中或同步块中 sleep()：休眠一段时间；不会释放锁 interrupt()：打断线程，强制结束...
Thread类的基本用法：线程创建、中断、等待、获取实例
weixin_62490144的博客
11-24 539
javaee当中，Thread的基本使用方法。
Thread类的常用方法
weixin_45990065的博客
11-26 245
Thread类的常用方法 1.start（）：启动当前线程，调用当前线程的run（） 2.run（）：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 3.currentThread（）：静态方法，返回执行当前代码的线程 4.getName（）：获取当前线程的名字 5.setName（）：设置当前线程的名字 6.yield（）：释放当前cpu的执行权 7.join（）：在线程a中调用线程b的join（），此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
Thread一些基本的用法
u011252234的专栏
07-14 936
thread一些基本的用法1.Thread的用法1.1没什么详细解释，直接看用法1.2代码-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{ //一个NSThread对象就代表一条线程 //创建（局部变量，当执行完run后自动销毁） // NSThread *thread=[[N
Java Thread类详解：构造器、方法与优先级
首先，让我们了解一下Thread类的基本构造器： 1. **Thread()**: 无参构造器，用于创建一个新的线程对象，但没有指定线程名称。当子类没有提供自定义构造器时，系统默认使用此构造器，并通过super()调用父类Thread的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值