多线程(二):Thread类的常见方法

已于 2022-08-24 09:59:03 修改
阅读量519 收藏 2
点赞数 9
分类专栏： 多线程 文章标签： java jvm 开发语言
于 2022-08-16 12:47:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57735833/article/details/126340864
版权

往期回顾:
❀❀多线程(一):认识和创建一个线程❀❀

Thread类的常见方法

一.构造方法

方法说明
Thread()创建线程对象
Thread(Runnable target)使用 Runnable 对象创建线程对象
Thread(String name)创建线程对象，并命名
Thread(Runnable target, String name)使用 Runnable 对象创建线程对象，并命名
public class ThreadMethod{
    public static void main(String[] args) {
        Thread t1 = new Thread();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("创建一个线程");
            }
        });
        Thread t3 = new Thread("我是一个线程");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("创建一个线程");
            }
        },"我也是线程");
    }
}

二.常见属性

1.ID

ID 是线程的唯一标识，不同线程不会重复,使用getId()获取

2.Name

name属性通常用于调试程序

        Thread thread1 = new Thread(new MyThread(),"thread1");
        Thread thread2 = new Thread(new MyThread(),"thread2");
        System.out.println("thread1.getId() = " + thread1.getId());
        System.out.println("thread2.getId() = " + thread2.getId());
        System.out.println("thread1.getName() = " + thread1.getName());
        System.out.println("thread2.getName() = " + thread2.getName());

在这里插入图片描述

3.状态

在Java当中把对线程的状态分得比原生操作系统更加细致,在Thread类内部,定义了一个枚举类型State,定义了线程的6种状态,如下

public enum State {
        
        NEW,

        RUNNABLE,

        BLOCKED,

        WAITING,

        TIMED_WAITING,

        TERMINATED;
    }
  1. NEW:线程刚创建出来,还未执行start()方法之前处于NEW状态.
 	    Thread thread = new Thread(new ThreadMethod());
        System.out.println("thread.getState() = " + thread.getState());

在这里插入图片描述

2.RUNNABLE:线程处于运行状态或者处在就绪队列,等待CPU资源

	   Thread thread = new Thread(new ThreadMethod());
       System.out.println("thread.getState() = " + thread.getState());
       thread.start();
       System.out.println("thread.getState() = " + thread.getState());

在这里插入图片描述

3.TERMINATED结束状态,表示线程已经执行完毕

       Thread thread = new Thread(new ThreadMethod());
       System.out.println("thread.getState() = " + thread.getState());
       thread.start();
       System.out.println("thread.getState() = " + thread.getState());
       Thread.sleep(100);
       System.out.println("thread.getState() = " + thread.getState());

在这里插入图片描述

4.BLOCKED: 这个状态表示线程正在等待锁资源

public class ThreadDemo implements Runnable {

    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadDemo());
        thread.start();
        Thread thread1 = new Thread(new ThreadDemo());
        thread1.start();
        Thread.sleep(1000);
        System.out.println("thread1.getState() = " + thread1.getState());
    }
    @Override
    public void run() {
        synchronized (lock){
            System.out.println(Thread.currentThread().getName()+" synchronized 加锁");
            // 休眠 5 秒
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" synchronized 释放锁");
        }
    }
}

可以看到,当thread开始执行时,进入synchronized 代码块,而后来的线程thread因为无法进入synchronized而阻塞,进入BLOCKED状态
在这里插入图片描述

5.WAITING: 查看源码–>
在这里插入图片描述
发现,当线程调用上面3个方法时,会进入WAITING状态
如:

public class ThreadState implements Runnable{
    @Override
    public synchronized void run() {
        while (true) {
            try {
                this.wait();
                this.notify();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadState());
        thread.start();
        Thread.sleep(1000);
        System.out.println("thread.getState() = " + thread.getState());
    } }

在这里插入图片描述

6.TIMED_WAITING: 查看源码–>
在这里插入图片描述
当线程进入有限等待时进入TIMED_WAITING状态.

如:

public class ThreadState implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadState());
        thread.start();
        Thread.sleep(1000);
        System.out.println("thread.getState() = " + thread.getState());
    } }

输出
在这里插入图片描述
同理join()与wait()带参数的版本可以达到同样的效果

4.优先级

优先级高的线程理论上来说更容易被调度到
具体的调用规则由操作系统内核决定.

		thread1.setPriority(2);
        System.out.println("thread1.getPriority() = " + thread1.getPriority());

在这里插入图片描述

**Thread提供的优先级为10个等级,1为支持得最小优先级,10为最大,如果设置的优先级不在1~10之间,会抛出异常在这里插入图片描述
当创建一个线程时,默认的优先级为5

5.是否守护线程

守护线程区分与用户进程

守护进程:是一种特殊的进程,为用户进程提供服务的一种进程,当用户进程全部执行完毕后,虚拟机会kill全部的守护进程
用户进程:一个进程运行时,默认都是用户进程,要想让线程变为守护进程,需要调用 setDaemon()方法

实例 1:

当thread不是守护线程时,main()线程结束后,程序继续运行,且在死循环中无法退出.

class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 1 ; ; ++i){
            System.out.println("i = " + i);
        }
    }
}

public class ThreadMethod{
    public static void main(String[] args) {
        System.out.println("main() 线程开始运行..");

        Thread thread = new Thread(new MyThread());
        
        thread.start();
    }
}

在这里插入图片描述

当把thread设置为守护线程时,main()线程结束后,程序就结束了,thread线程被kill

		System.out.println("main() 线程开始运行..");

        Thread thread = new Thread(new MyThread());
        // 设置thread为守护线程
        thread.setDaemon(true);
        thread.start();

在这里插入图片描述
实例 2:

形如垃圾回收线程,当用户进程结束时,也就不会产生垃圾,也就不需要垃圾回收了.

6.是否存活

run 方法执行结束前,线程存活

class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 1 ; i <  5; ++i){
            System.out.println("i = " + i);
        }
    }
}

public class ThreadMethod{
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyThread());
        System.out.println("thread.isAlive() = " + thread.isAlive());
        thread.start();
        System.out.println("thread.isAlive() = " + thread.isAlive());
        Thread.sleep(100L);   // 让线程休眠 100 ms
        System.out.println("thread.isAlive() = " + thread.isAlive());
	}
}

在这里插入图片描述

7.是否被中断

使用thread.isInterrupted()判断线程是否被中断,被中断返回true
使用thread.intrerupt()中断thread线程

三.常见方法

1.start()

重写run()方法时,就是指定线程任务,当我们new Thread()时,并不代表线程开始运行,只有当我们调用start()方法时,才会在操作系统底层创建出一个线程.

2.interrupt(),isInterrupted(),interrupted()

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

(1).使用自定义的变量来作为标志位.

public class ThreadMethod implements Runnable{
    @Override
    public void run() {
    	// 当isQuit为false进入循环
        while (!isQuit){
            System.out.println("线程运行中");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("线程结束");
    }
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new ThreadMethod());
        thread.start();
        Thread.sleep(6000);
        // 休眠6s后,将标志位设置位ture,循环条件不满足,结束thread线程
        isQuit = true;
    }
}

运行结果
在这里插入图片描述

(2).使用thread.isInterrupted()代替标志位

public class ThreadMethod implements Runnable{
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()){
            System.out.println("线程运行中");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("线程结束");
    }
//    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new ThreadMethod());
        thread.start();
        System.out.println("thread.isInterrupted() = " + thread.isInterrupted());
        Thread.sleep(6000);
        thread.interrupt();
        System.out.println("thread.isInterrupted() = " + thread.isInterrupted());
	}
}

Thread.currentThread()为获取当前线程引用

运行上述代码,得到如下结果
在这里插入图片描述
可以发现,程序抛出异常,并且循环并没有结束,因为当程序执行thread.interrupt();的时候,有两种情况

1: 当线程处在运行状态,interrupt()会修改标志位为true.
2.当线程处于阻塞状态时,会抛出InterruptedException()异常,此时程序是否继续运行,取决于代码中catch中的实现.

(3).观察interrupted()与isInterrupted()的区别

interrupted()与isInterrupted()的区别在于执行后是否将标志位重置为false

// isInterrupted()演示
public class ThreadMethod implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread.currentThread().isInterrupted() = " + Thread.currentThread().isInterrupted());
        }
    }

    //    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new ThreadMethod());
        thread.start();
        thread.interrupt();
    }
}

输出
在这里插入图片描述
因为标记为未被重置,所以全部输出true

// Thread.interrupted()演示
public class ThreadMethod implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread.interrupted() = " + Thread.interrupted());
        }
    }

    //    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new ThreadMethod());
        thread.start();
        thread.interrupt();
    }
}

输出
在这里插入图片描述
因为输出 true之后,标记为被重置,所以后续输出 false

3.join()

当一个线程A调用某一个线程B的join()方法时,当前线程A将会进入等待状态,只有当B线程执行完毕之后,A线程才能继续执行.

public class ThreadMethod implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始运行");
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
        System.out.println(Thread.currentThread().getName()+"结束运行");
    }

    //    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new ThreadMethod(),"thread");
        thread.start();
        System.out.println("main() 线程结束...");
    }
}

运行结果
在这里插入图片描述
可以发现,当程序运行时,main线程先执行完毕,thread线程才开始执行,那么,如何让thread线程执行完毕之后,main线程才结束呢

		Thread thread = new Thread(new ThreadMethod(),"thread");
        thread.start();
        // 加入 thread.join() 这是,main将等待 thread结束之后才会继续往下执行
        thread.join();
        System.out.println("main() 线程结束...");

结果
在这里插入图片描述

除此之外,join()还可以传入一个毫秒数,代表最多等待多久

4.获取当前线程引用

Thread.currentThread();

5.线程休眠

public static void sleep(long millis) throws InterruptedException ,millis为休眠的毫秒数,这个方法可能会抛出异常

系列文章
❀❀❀多线程(一):认识和创建一个线程❀❀❀
❀❀❀多线程(三):synchronized解决线程不安全❀❀❀
努力写代码的菜鸟
关注
  • 9
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
多线程学习:线程创建详解
12-22
  线程创建包含线程生命周期中的 新建、就绪、运行 三种状态，相关的api为java.lang.Thread 类   ① 新建状态：就是刚使用new方法，new出来的线程 如常见的两种方式   方式一：继承Thread类，并初始化Thread...
Java中Thread 类的五种基本用法(简介)
qq_62718027的博客
06-21 1356
这个时候就先打印了函数,五秒之后再打印线程里面的内容,这就是休眠sleep的用法!不就是我们在打断方法的时候用过的Thread.currentThread()吗。由于程序是并发运行的,但是运行线程的时候遇到了sleep,短暂休眠了5秒。就是自己设置一个变量,如果满足则线程继续执行,如果不满足则结束。5.使用匿名内部类,实现Runnable,重写run。4.使用匿名内部类,继承Thread,重写run。这我的这篇博客详细介绍了这五种方法的代码和实现。只要调用了join,那么后面的代码就一定后执行。
多线程篇2——Thread类实现多线程
技术尖刀的博客
02-28 857
一、Thread类实现多线程的方式 需要继承Thread类 必须要重写run方法，指的是核心执行的逻辑 线程在启动的时候，不要直接调用run方法，而是要通过start()来进行调用 二、 实例 public class ThreadDemo extends Thread{ @Override public void run() { for(int i = 0;i<10;i++){ System.out.println(Thread.cu
【Java学习笔记】多线程
weixin_52144018的博客
03-20 325
【Java学习笔记】多线程
多线程——Thread类
dgh112233的博客
03-31 267
Thread类 线程状态代表一个线程在生命周期中所处的状态或者阶段。 public class Thread implements Runnable { public enum State { 用new创建了之后，但是还未start运行 NEW, 正在执行状态 RUNNABLE, 阻塞状态 ...
java new thread()_(一)java多线程之Thread
weixin_39619478的博客
02-16 6215
Thread类学习java线程的开发者,首先遇到的第一个类就是Thread,通过使用Thread类,我们就可以启动,停止,中断一个线程. 在同一个时间片里, 可能会有多个线程在执行, 每个线程都拥有它自己的方法调用堆栈, 参数和变量.每个app至少会有一个线程--主线程(main thread).创建一个线程java创建线程有两种方式创建一个继承Thread的子类,并实现run方法使用Thread...
多线程—Thread类的用法
m0_62824239的博客
03-23 712
目录什么是Thread类Thread类的基本用法线程创建最基本的创建方法实现runnable接口使用匿名内部类lambda表达式 Java这个生态中最常用的并发编程方式是多线程。 什么是Thread类 在java标准库中，就提供了一个Thread类，来表示/操作线程。Thread类也可以视为Java标准库提供的API，创建好的Thread实例，其实和操作系统中的线程是一一对应的关系，操作系统，提供了一组关于线程的API，Java对于这组API进一步封装，就成了Thread类。 Thread类的基本用法 线程
【Java】多线程--Thread类基本用法
m0_57680308的博客
09-27 936
Thread类是Java中的一个封装类，用于实现多线程操作，下面是Thread类一些基本用法。
1、java线程（thread）实现多线程的三种方法
康康的博客
07-07 863
进程（process）可以包含多个线程 三种创建方式： Thread class 继承Thread类不建议使用：避免OOP单继承局限性。 Runnable接口 实现Runnable接口推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用 Callable接口 实现Callable接口 注意：线程开启不一定立即执行，由CPU调度执行。 1、自定义线程类继承Thread类，重写run()方法，编写线程执行体，创建线程对象，调用start()方法启...
创建线程(异步/多线程)的四种方式-Thread/Runnable/ThreadPoolExecutor/Callable+Spring框架用法
天道酬勤
09-26 6828
创建线程(异步/多线程)的四种方式-Thread/Runnable/ThreadPoolExecutor/Callable+Spring框架用法
一文带你搞懂C#多线程的5种写法
热门推荐
买烤麸烤饼儿的博客
05-29 3万+
一文带你搞懂C#多线程的5种写法 1.简介 超长警告！ 在学习本篇文章前你需要学习的相关知识： 线程基本知识 此篇文章简单总结了C#中主要的多线程实现方法，包括： Thread 线程 ThreadPool 线程池 Parallel Task 任务 BackgroundWorker组件 2. Thread类 2.1 概述 使用Thread类通过ThreadStart（无参数）或ParameterizedThreadStart（一个输入参数）类型的委托创建一个Thread对象，开启一个新线程，执行该委托
C#基础系列：多线程的常见用法详解
01-20
前言：此篇主要从博主使用过的几种多线程的用法从应用层面大概介绍下。... 　（1）简单、原始的使用方法：Thread oGetArgThread = new Thread(new ThreadStart(() =>{});这种用法应该大多数人都使用过，参数为一个Thre
浅谈Android中多线程切换的几种方法
01-21
我们知道，多线程是Android开发中必现的场景，很多原生API和开源项目都有多线程的内容，这里简单总结和探讨一下常见的多线程切换方式。 我们先回顾一下Java多线程的几个基础内容，然后再分析总结一些经典代码中对于...
Threads:常见的多线程实用程序的集合
05-23
线程数常见的多线程实用程序的集合BlockingQueue_util callable_future死锁扩展线程实现可运行的线程间通信通讯lock_objects low_level_synchronization_wait_notify reentrant_lock信号量静态方法同步synchronized_...
Linux多线程服务端编程：使用muduo C++网络库
02-13
本书主要讲述采用现代C++ 在x86-64 Linux 上编写多线程TCP 网络服务程序的主流常规技术，重点讲解一种适应性较强的多线程服务器的编程模型，即one loop per thread。这是在Linux 下以native 语言编写用户态高性能...
Java基础篇 - 多线程详解
XXXanghongin的博客
05-18 526
1.线程相关概念 1.1 程序 是为了完成特定任务，用某种语言编写的一组指令的集合。 简单的说，就是我们写的代码 1.2 进程 进程是指运行中的程序，比如我们使用了QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们玩游戏时，又启动了一个进程，操作系统会为该游戏分配新的内存空间。 进程是程序的一次执行过程，或者是正在运行的一个程序，是动态过程：有他自身的产生，存在和 ...
实现多线程的两种方式
超级程序诞生的博客
04-30 1014
一、线程详解： 在操作系统中运行的程序就是进程，比如你的qq，播放器，游戏，IDE等等。。。 一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，叫main线程，不然没有存在的意义。线程是CPU调度和执行的单位。 注意：很多线程是模拟出来的，
JAVA多线程Ⅰ
m0_64436238的博客
01-03 381
一、了解（并发&并行） 并行：同一时刻，多个指令在（多个）cpu上----同时----执行（多个人同时处理多件事） 并发：同一时刻，多个指令在（单个）cpu上----交替----执行（一个人同时交替处理多件事） 二、了解（多线程&单线程） 多线程：指从软件或者硬件上实现多个线程并发执行的技术。具有多线程处理能力的计算机因有硬件的支持而能够在同一时间执行多个线程，提升性能 单线程：一次处理一个线程 三、了解（进程&线程） 进程：比如任务管理器上看见的正在运行的.
Thread的基本操作
pawlaibd的博客
03-18 1219
了解线程的创建 , 线程的状态 , 线程的一些常见属性
Android支持三种多线程实现方法：继承Thread类、实现Runnable接口和使用AsyncTask类。他们的区别简述使用场景
最新发布
08-05
Android支持三种多线程实现方法的区别在于：继承Thread类提供了更多的灵活性，可以更容易地实现一个完整的多线程模型；实现Runnable接口更加简单，可以在新线程中执行任务；使用AsyncTask类可以在UI线程中执行任务，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力写代码的菜鸟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值