多线程-线程的创建、中断、等待、休眠和获取线程引用

已于 2022-04-14 22:26:25 修改
阅读量988 收藏 7
点赞数
分类专栏： 多线程笔记 文章标签： java-ee
于 2022-03-25 23:34:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48271092/article/details/123745997
版权

今天来总结下Thread类的用法，包括Thread的创建、中断、等待、休眠以及获取线程实例的用法。

目录

一、线程的创建

1.1 继承Thread

1.1.1通过继承Thread类来创建线程

1.1.2  变种方法1

1.1.3  启动线程——start()方法

1.1.3  start()和run()的区别

1.2 实现Runnable接口

1.2.1  基础实现Runnable接口

1.2.2  变种方法1：匿名实现Runnable接口

1.2.3  变种方法2：使用Lambda表达式

1.3 实现带返回值的Callable接口

1.3.1  基础实现Callable接口

 1.3.2  Lambda表达式实现Callable接口

1.4  线程创建总结

二、线程中断

2.1 自定义标识符中断线程

2.2 使用interrupt()方法中断

三、线程等待

3.1 join()无限等待

3.2 join(long millions)有限等待

四、线程休眠

4.1 使用sleep()休眠

4.2 使用TimeUnit休眠

五、获取线程实例

一、线程的创建

线程的创建有三种方式：分别是继承Thread、实现Runnable接口 、实现Callable接口。

1.1 继承Thread

1.1.1通过继承Thread类来创建线程

/**
 * 继承Thread创建线程
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //获得当前线程
        Thread mainThread=Thread.currentThread();
        System.out.println("线程名称："+mainThread.getName());
        MyThread myThread=new MyThread();
        //开启线程
        myThread.start();
    }
}
class MyThread extends Thread{
    @Override
    public void run(){
        //具体的业务代码
        Thread thread=Thread.currentThread();
        System.out.println("线程的名称："+thread.getName());
    }
}

1.1.2  变种方法1

通过匿名内部类来实现继承Thread类的过程。

public class ThreadDemo7 {
    public static void main(String[] args) {
        Thread thread=new Thread(){
            //匿名内部类
            @Override
            public void run() {
               Thread thread1=Thread.currentThread();
                System.out.println("线程执行："+thread1.getName());
            }
        };
        thread.start();
    }
}

1.1.3  启动线程——start()方法

由上面的创建线程可以看到我们通过覆写run()方法来创建了一个线程，但是创建了线程不代表线程开始运行，我们还需要用到start()方法来启动线程，线程才能开始运行。

那么我们可以看到用run()方法，线程也能开始运行，那么run()方法也可以启动线程吗？

/**
 * 继承Thread创建线程
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //获得当前线程
        Thread mainThread=Thread.currentThread();
        System.out.println("线程名称："+mainThread.getName());
        MyThread myThread=new MyThread();//新建状态
        //开启线程
//        myThread.start();//Runnable
        myThread.run();
//        myThread.run();
    }
}
class MyThread extends Thread{
    @Override
    public void run(){
        //具体的业务代码
        Thread thread=Thread.currentThread();
        System.out.println("线程的名称："+thread.getName());
    }
}

虽然都能成功运行，但是与上面两种方法的运行结果有所不同，那就是线程的名称不相同。

我们可以发现调用run()方法，其实是用当前程序的主线程main来执行方法体的；而start()方法则是真正创建一个新线程来执任务。

1.1.3  start()和run()的区别

区别一：调用run()方法是主线程执行一个普通的run()方法，并不是开启新线程；调用start()方法是真正开启一个新线程来执行任务。

区别二：run 方法也叫做线程体，它里面包含了具体要执行的业务代码，当调用 run 方法时，会立即执行 run 方法中的代码（如果当前线程时间片未用完）；而调用 start 方法时，是启动一个线程并将线程的状态设置为就绪状态。也就是说调用 start 方法，并不会立即执行。

区别三：run()是普通方法，因此可以调用多次，而start()方法是用来创建新线程执行任务的 ，在调用start()方法之前，线程的状态是新建状态，在调用start()方法之后，线程就变为就绪状态，线程的状态是不可逆的，因此start()方法只能调用一次。

/**
 * 继承Thread创建线程
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //获得当前线程
        Thread mainThread=Thread.currentThread();
        System.out.println("线程名称："+mainThread.getName());
        MyThread myThread=new MyThread();//新建状态
        //开启线程
//        myThread.start();//Runnable
        myThread.run();
        myThread.run();
    }
}
class MyThread extends Thread{
    @Override
    public void run(){
        //具体的业务代码
        System.out.println("线程的名称："+thread.getName());
    }
}

1.2 实现Runnable接口

1.2.1  基础实现Runnable接口

public class ThreadDemo4 {
    public static void main(String[] args) {
        MyThread1 myThread1=new MyThread1();
        Thread thread=new Thread(myThread1);
        thread.start();
    }

}
class MyThread1 implements Runnable{
    @Override
    public void run() {
        //具体的业务代码
        Thread thread=Thread.currentThread();
        System.out.println("线程执行："+thread.getName());
    }
}

1.2.2  变种方法1：匿名实现Runnable接口

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            //匿名内部类
            @Override
            public void run() {
                Thread thread1=Thread.currentThread();
                System.out.println("线程执行："+thread1.getName());
            }
        });
        thread.start();
    }
}

1.2.3  变种方法2：使用Lambda表达式

public class ThreadDemo6 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            Thread thread1 = Thread.currentThread();
            System.out.println("线程执行：" + thread1.getName());
        });
        thread.start();
    }
}

1.3 实现带返回值的Callable接口

1.3.1  基础实现Callable接口

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 实现Callable接口 新建线程
 */
public class ThreadDemo8 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable实例
        MyCallable myCallable=new MyCallable();
        //用于接收Callable结果的对象
        FutureTask<Integer> futureTask=new FutureTask<Integer>(myCallable);
        //创建新线程
        Thread thread=new Thread(futureTask);
        //启动线程
        thread.start();
        //接收新线程执行后的结果
        int result=futureTask.get();
        System.out.println(Thread.currentThread().getName()+"新线程返回的结果为："+result);
    }
}

/**
 * Callable<V>泛型里面可以是任意数据类型
 */
class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        //随机数范围：0-9
        int num=new Random().nextInt(10);
        System.out.println(Thread.currentThread().getName()+" "+"随机数："+num);
        return num;
    }
}

 1.3.2  Lambda表达式实现Callable接口

import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo9 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask=new FutureTask<Integer>(()->{
            int num=new Random().nextInt(10);
            System.out.println(Thread.currentThread().getName()+" "+"生成的随机数:"+num);
            return num;
        });
        Thread thread=new Thread(futureTask);
        thread.start();
        int result=futureTask.get();
        System.out.println(Thread.currentThread().getName()+" "+"中得到新线程的返回结果："+result);
    }
}

1.4  线程创建总结

创建线程共有3大类实现方式，7种实现方法，以上方法支持JDK1.8及以上版本，如果不需要得到线程的执行结果，可以使用Lambda表达式实现Runnable接口的方式创建线程，若需要得到线程的执行结果，可以使用FutureTask+Callable的方式创建线程。

二、线程中断

2.1 自定义标识符中断线程

/**
 * 中断线程1.自定义标识符
 */
public class ThreadDemoInterrupt {
    public static  volatile boolean flag=false;
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (!flag){
                System.out.println("正在转账...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("差点误了大事!");
        });
        t.start();
        Thread.sleep(3000);
        //终止线程
        System.out.println("有内鬼终止交易");
        flag=true;

    }
}

2.2 使用interrupt()方法中断

使用Thread.interrupted()或者Thread.currentThread.isInterrupted()来代替自定义标志位，来判断当前线程的中断标志位是否被设置，若被设置返回true，否则返回false。

Thread 内部包含了⼀个 boolean 类型的变量作为线程是否被中断的标记.

⽅法说明
public void interrupt()中断对象关联的线程，如果线程正在阻塞，则以
异常⽅式通知，否则设置标志位
public static boolean interrupted()判断当前线程的中断标志位是否设置，调⽤后清
除标志位
public boolean isInterrupted()判断对象关联的线程的标志位是否设置，调⽤后
不清除标志位

isInterrupted()：调用后不清除标志位；

interrupt(): 调用后清除标志位。

/**
 * 使用interrup方法终止线程
 */
public class ThreadDemoInterrupt2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            System.out.println("终止标志位："+Thread.currentThread().isInterrupted());
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("正在转账...");
            }
            System.out.println("险些误了大事！");
            System.out.println("终止标志位2："+Thread.currentThread().isInterrupted());
            System.out.println("终止标志位2："+Thread.currentThread().isInterrupted());
            System.out.println("终止标志位2："+Thread.currentThread().isInterrupted());
            System.out.println("终止标志位2："+Thread.currentThread().isInterrupted());
            System.out.println();
            System.out.println("终止标志位4："+Thread.interrupted());
            System.out.println("终止标志位4："+Thread.interrupted());
            System.out.println("终止标志位4："+Thread.interrupted());
            System.out.println("终止标志位4："+Thread.interrupted());

        });
        t.start();
        Thread.sleep(100);
        //终止线程
        t.interrupt();
        System.out.println("有内鬼终止交易");
        System.out.println("终止标志位3："+t.isInterrupted());

    }
}

 isInterrupted()和interrupted()区别：

1.interrupted()属于静态方法，所有程序都可以直接使用的全局方法；而 isInterrupted()属     于某个实例的方法。

2.interrupted()在使用完之后会重置中断标志符，而 isInterrupted()不会重置中断标志符。

 thread收到通知的方法有两种：

1.如果线程因为调用sleep/wait/join等方法而挂起，则以InterruptrdException异常的形式通知，清除中断标志。

    ·  当出现InterruptrdException异常时，要不要结束线程取决于catch中代码的写法，可以选择忽         略这个异常，也可以跳出循环结束线程。

public class ThreadSleep {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            try {
                Thread.sleep(60*60*1000);
            } catch (InterruptedException e) {
                System.out.println("我收到终止线程的通知");
//                e.printStackTrace();
            }
        });
        thread.start();
        Thread.sleep(1000);
        System.out.println("终止子线程thread");
        thread.interrupt();

    }
}

2.否则只是内部的一个中断标志被设置，可以通过Thread.interrupted()或者         Thread.currentThread.isInterrupted()来判断。

三、线程等待

有时我们需要等待一个线程执行完之后再进行下一个线程的执行，这是就要用到join()方法来等待线程执行结束 。

方法说明
public void join()等待线程结束
public void join(long millis)等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)同理，但可以更高精度

3.1 join()无限等待

import java.time.LocalDateTime;

/**
 * join方法示例
 */
public class ThreadDemoByJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            System.out.println("1.张三开始上班");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2.张三下班");
        });
        t.start();

        //等待线程t执行完之后，再执行后面的代码
        t.join();
        Thread t1=new Thread(()->{
            System.out.println("3.李四开始上班");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("4.李四下班");
        });
        t1.start();
    }
}

3.2 join(long millions)有限等待

当超过join的等待时间时，就不再继续这个线程执行结束，而是继续向下执行下一个线程的任务。

import java.time.LocalDateTime;

/**
 * join方法示例
 */
public class ThreadDemoByJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            System.out.println("1.张三开始上班"+LocalDateTime.now());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2.张三下班"+LocalDateTime.now());
        });
        t.start();
        t.join(500);
        Thread t1=new Thread(()->{
            System.out.println("3.李四开始上班"+LocalDateTime.now());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("4.李四下班"+LocalDateTime.now());
        });
        t1.start();
    }
}

四、线程休眠

线程的休眠有两种方式：

1.使用sleep()进行休眠

2.使用TimeUnit进行休眠

3.使用wait()也可以进行休眠。

wait与sleep的区别：https://blog.csdn.net/weixin_48271092/article/details/124128061

4.1 使用sleep()休眠

方法说明
public static void sleep(long millis) throws
InterruptedException		休眠当前线程 millis 毫秒
public static void sleep(long millis, int nanos)
throws InterruptedException		可以更高精度的休眠
import java.time.LocalDateTime;


public class ThreadTimeUtil {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("线程开始执行时间："+LocalDateTime.now());
        Thread.sleep(1000*3);
        System.out.println("线程结束时间："+LocalDateTime.now());
    }
}

4.2 使用TimeUnit休眠

import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

public class ThreadTimeUtil {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始执行了："+ LocalDateTime.now());
        TimeUnit.SECONDS.sleep(3);
        System.out.println("主线程又开始了："+LocalDateTime.now());
    }
}

五、获取线程实例

方法说明
public static Thread currentThread();返回当前线程对象的引⽤
public class ThreadDemo {
    public static void main(String[] args) {
         Thread thread=Thread.currentThread();
         System.out.println("线程执行："+thread.getName());
    }
}

线程的常见几种用法就总结到这里了~

一个很酷的女巫_
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实现线程的两种方式和线程休眠
zs1342084776的博客
08-11 4352
package com.vince; /** *线程的休眠 * 在当前线程的执行中，暂停指定的毫秒数，释放CPU时间片 * millis:以毫秒为单位的睡眠时间长度 * InterruptedException：如果任何线程中断当前线程，当抛出此异常时，当前线程的中断状态将被清除 * Thread.currentThread(): 获取当前线程 * */ /** * 继承...
总结Thred的基本用法，包括线程创建，线程中断，线程等待，线程休眠，获取线程实例
HBINen的博客
08-29 553
总结Thread的基础用法（详细）包括：线程创建，线程中断，线程等待，线程休眠，获取线程实例
线程(4)，等待，休眠，状态
shadow___h的博客
06-08 345
线程等待 线程之间是并发执行的关系 多个线程之间，谁先执行，谁后执行，谁执行到那里让cpu运行，我们是无法是控制的，只能让系统的内核去控制 但是我们可以控制用jion方法来让那个线程去先结束 jion方法，执行jion方法线程就会阻塞，一直到等到对应线程的jion方法执行完才会执行，join方法存在的意义就是为了控制线程结束得先后顺序 2.线程休眠 就是让正在的运行的线程去休息一会，等段时间在执行 sleep就是让对应线程的PCB从就绪队列进入到阻塞队列 线程状态 NEW Thre.
线程创建等待及退出
weixin_42900834的博客
03-02 218
1.linux上线程开发API概要 多线程开发在 Linux 平台上已经有成熟的 pthread 库支持,(在程序运行的时候要假如-lpthread),其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。其中，线程操作又分线程的创建，退出，等待 3 种。互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。条件操作有 5 种操作：创建，销毁，触发，广播和等待。 2.线程的创建，退出以及等待 （1）线程的创建原型 #include <pthread.h> int pthread_cr
线程中各种唤醒、等待、睡眠方法之间的区别
深蓝色的忧伤
04-01 603
[b]一、notify()方法和notifyAll()方法的区别[/b] notifyAll使所有原来在该对象上等待被notify的线程统统退出wait的状态，变成等待该对象上的锁，一旦该对象被解锁，他们就会去竞争。 notify则文明得多他只是选择一个wait状态线程进行通知，并使它获得该对象上的锁，但不惊动其他同样在等待被该对象notify的线程们，当第一个线程运行完毕以后释放对象上的...
java基本教程之线程休眠 java多线程教程
09-04
多线程使得程序可以在同一时间处理多个任务，提高系统效率。本文将深入讲解`sleep()`方法，这是Java中控制线程休眠的重要工具。 1. `sleep()`介绍 `sleep()`方法位于`java.lang.Thread`类中，它允许当前正在执行的...
一个支持多线程断点续传功能的Android下载工具.zip
03-03
在传统的一线程下载中，数据流是单向的，而多线程则可以同时从服务器获取多个数据流，显著提高了下载速度。在Android的DownloadHelper项目中，虽然当前版本仅支持单任务单线程，但其标签明确表示将支持多任务多线程...
JAVA多线程共13页.pdf.zip
11-21
8. **线程池**：通过ExecutorService接口和ThreadPoolExecutor类，可以创建线程池，有效地管理线程的创建和销毁，提高系统性能并避免资源浪费。 9. **并发工具类**：Java并发包（java.util.concurrent）提供了一...
多线程实现30个人抢五个座位
12-21
本题目“多线程实现30个人抢五个座位”是一道典型的多线程同步问题，用于考察程序员对并发控制的理解和应用。下面我们将详细探讨这个问题的解决方案及其背后的原理。 首先，代码中定义了一个名为`Seat`的类，该类...
15个顶级Java多线程面试题（附答案）
08-31
Java多线程是Java编程中不可或缺的部分，...这些面试问题旨在测试面试者对Java多线程并发控制、同步机制、线程安全和性能优化的理解。掌握这些知识点对于在Java开发，尤其是高并发和实时交易系统领域的工作至关重要。
【线程创建、线程等待、线程退出、线程互斥锁】
anmo_moan的博客
10-06 618
线程的创建，等待，退出，同步
线程等待及休眠
qq_44773719的博客
12-30 603
1.线程等待 join() 有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。 public class JoinTest { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new Runnable() { ...
Java并发编程 —— 线程的创建、线程休眠
MercuryG的博客
06-08 421
进程vs线程： 1、进程是系统分配资源的最小单位；线程是系统调度的最小单位 2、一个进程中至少要包含一个线程 3、线程必须要依附于继承，线程是进程实质工作的一个最小单位 线程的创建方式： 1、继承Thread类 实现线程的创建（2种写法） 1.1种写法 public class ThreadDemo03 { static class MyThread extends Thread{ @Override public void run(){
Java多线程-41-获取当前线程对象和线程休眠
Anthony_tester的博客
08-30 5244
这篇学习关于Thread类的两个方法，第一个是获取当前线程对象，返回的是一个Thread对象。第二个方法是我们自动化中经常使用的，线程休眠。 1.currentThread() 获取的是当前线程对象，是对象不是对象名称，如果要获取名称，需要对象.getName()实现。 package thread; public class Demo5_Thread { public static...
线程的启动与休眠
欢迎来到李奇峰的数据世界
04-05 1461
上一节介绍了线程的创建之后呢，我们来讲讲线程的启动与休眠 在讲具体内容之前，我们先来介绍一下线程的五种状态Java线程具有五中基本状态新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好
线程--中断(interruput),等待线程结束(join),休眠(sleep)
Nabandon的博客
06-03 438
1.线程中断 (1)通过thread 对象调用 interrupt 方法通知线程中断. (2). thread 收到通知的方式有两种： 如果线程调用了 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志 否则，只是内部的一个中断标志被设置，thread 可以通过 (设置中断标志:true; 清除中断标志:false) ①. Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志 ② Thread.c
线程的休眠和中断
weixin_30539625的博客
08-06 178
在程序中允许一个线程进行暂时的休眠，直接使用Thread.sleep()方法即可实现休眠： class myThread11 implements Runnable { public void run() { for (int i = 0; i < 5; i++) { try { Thre...
创建线程以及中断线程详解以及代码实现
weixin_45842420的博客
06-30 185
创建线程以及中断线程的详细介绍
java中断程序运行，超时中断
qq_42543912的博客
04-15 769
java中断程序运行，超时中断 public class TimeCount { final static int MAX_THREADS = 50; //最大线程数量 final static long timeout = 7200; //设置超时时间（秒） public static boolean timec(final DisposeService oldService, final Map map, final String tFlag) { //线
线程休眠和线程让步的区别
最新发布
07-01
在线程调度中，休眠（sleep）和让步（yield）都是控制线程执行流程的方式，但它们的目的和影响有所不同。 1. **线程休眠（sleep）**： - 线程休眠是让当前线程暂停执行指定的时间（以毫秒或微秒为单位），这段时间内，线程会释放CPU资源，让其他线程有机会运行。 - 这是一个阻塞操作，休眠中的线程不会占用处理器时间，直到睡眠期结束才会重新获取CPU执行权。 - 如果有更高优先级的线程等待运行，那么即使休眠时间未到，该线程也可能被中断并切换。 2. **线程让步（yield）**： - 让步操作通常不是操作系统提供的原生功能，而是编程语言或API中的一种推荐实践（如Java的`Thread.yield()`）。 - 主要作用是让当前执行的线程主动放弃CPU控制权，给其他线程提供一个执行的机会，尤其是当多个线程在竞争资源时。 - 让步是可选的，不是强制性的，不保证立即切换线程，实际效果取决于操作系统的调度策略。 - 如果线程调度器没有将控制权切换给其他线程，线程可能很快又会重新获得CPU，这取决于调度算法和系统负载。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值