多线程详解（二）——Thread类中的常用方法

最新推荐文章于 2021-03-02 14:58:45 发布
最新推荐文章于 2021-03-02 14:58:45 发布
阅读量308 收藏
点赞数 1
分类专栏： JAVA 多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43912697/article/details/113869449
版权

一. 线程的五大状态：

新建状态：使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态，它保持这个状态直到程序 start() 这个线程。
就绪状态：当线程对象调用了start()方法之后，该线程就进入就绪状态，就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
运行状态：如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态，处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态：如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态，在睡眠时间已到或获得设备资源后可以重新进入就绪状态。
死亡状态：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

二. Thread类中的常用方法：

public void start() : 使该线程开始执行，Java 虚拟机调用该线程的 run 方法。
public void run() : 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法，否则，该方法不执行任何操作并返回。
public final void setName(String name) : 改变线程名称，使之与参数 name 相同。
public final void setPriority(int priority) : 更改线程的优先级。
public int getPriority() : 获取线程的优先级。
public final void setDaemon(boolean on) : 将该线程标记为守护线程或用户线程。
public void interrupt() ： 中断线程。
public final void join(long millisec) : 等待该线程终止的时间最长为 millis 毫秒。
public final boolean isAlive() : 测试线程是否处于活动状态。
public static void yield() : 暂停当前正在执行的线程对象，并执行其他线程。
public static void sleep(long millisec) : 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

三. 常用方法举例：

① 线程停止：

建议使用标志位，使线程正常停止
不要使用stop或者destory等过时或JDK不建议使用的方法

public class TestStop implements Runnable{
    private boolean flag = true;  // 设置一个标志位

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread..."+i++);
        }
    }

    // 设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main Thread..."+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程该停止了!");
            }
        }
    }
}
② 线程休眠——sleep():

sleep()方法存在异常InterruptedException
sleep()方法时间达到后线程进入就绪状态
每个都有一把锁，sleep方法不会释放锁

public class TestSleep{
    public static void main(String[] args) {
        try {
            Delay();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 模拟延时
    public static void Delay() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            System.out.println(new Date());
            Thread.sleep(2000);
        }
    }
}

结果：

Fri Feb 19 20:19:35 CST 2021
Fri Feb 19 20:19:37 CST 2021
Fri Feb 19 20:19:39 CST 2021
Fri Feb 19 20:19:41 CST 2021
Fri Feb 19 20:19:43 CST 2021
③ 线程礼让(暂停)——yield()：

礼让线程，yield()方法暂停正在执行的线程，但不堵塞
将线程从运行状态转为就绪状态
暂停正在执行的线程后，CPU重新调度新的线程，礼让(暂停)不一定成功！

package Thread;

public class TestYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始了");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束了");
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();
        new Thread(testYield,"a").start();
        new Thread(testYield,"b").start();
    }
}

注释掉yield()方法的结果：

a线程开始了
a线程结束了
b线程开始了
b线程结束了

没有注释的结果：

a线程开始了
b线程开始了
b线程结束了
a线程结束了
④ 线程强制执行——join():

join合并线程，待此线程完成后再执行其他线程，其他线程堵塞
可以想象成插队
可以给它一个时间参数join(long time)，表示最多等待time毫秒

public class TestJoin implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000);  // 延时1秒让主线程先走
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 5; i++) {
            System.out.println("线程vip来了..."+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 10; i++) {
            if (i==5)
                thread.join();
            System.out.println("main线程..."+i);
        }
    }
}

结果：

main线程...0
main线程...1
main线程...2
main线程...3
main线程...4
线程vip来了...0
线程vip来了...1
线程vip来了...2
线程vip来了...3
线程vip来了...4
main线程...5
main线程...6
main线程...7
main线程...8
main线程...9
⑤ 观测线程状态——isAlive()：

线程可以处于下列状态之一：
NEW：至今尚未启动的线程处于这种状态
RUNNABLE：正在 Java 虚拟机中执行的线程处于这种状态
BLOCKED：受阻塞并等待某个监视器锁的线程处于这种状态
WAITING：无限期地等待另一个线程来执行某一特定操作的线程处于这种状态
TIMED_WAITING：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态
TERMINATED：已退出的线程处于这种状态

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{  // lambda表达式
            for (int i = 0; i < 5; i++) {  // 延时5秒
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("======");
        });
        // 观察线程状态
        Thread.State state = thread.getState();  // 获取当前线程的状态
        System.out.println(state);  // NEW

        thread.start();  // 启动线程
        state = thread.getState();
        System.out.println(state);  // RUNNABLE

        if (thread.isAlive()){  // 判断线程是否处于活动状态
            System.out.println("此时的状态为RUNNABLE");
        }

        while (state!=Thread.State.TERMINATED){  // 只要线程没有结束
            Thread.sleep(500);  // 等半秒再观察
            state = thread.getState();  // 更新状态
            System.out.println(state);
        }
    }
}

结果：

NEW
RUNNABLE
此时的状态为RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
======
TERMINATED
⑥ 线程的优先级——setPriority(int priority)、getPriority():

线程的优先级用数字表示，范围为[1,10]
Thread.MAX_PRIORITY=10
Thread.MIN_PRIORITY=1
Thread.NORM_PRIORITY=5 (默认值)
优先级越高获得调度的概率越大

public class TestPriority {
    public static void main(String[] args) {
        // 打印主线程优先，应为默认优先级 5
        System.out.println(Thread.currentThread().getName()+"的优先级--->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        // 先设置优先级再启动
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(8);
        t4.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"的优先级--->"+Thread.currentThread().getPriority());
    }
}

结果：

main的优先级--->5
Thread-0的优先级--->10
Thread-3的优先级--->8
Thread-2的优先级--->4
Thread-1的优先级--->1
⑦ 守护线程——setDaemon(boolean on)：

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕
setDaemon(boolean on)：当on为true,则设置线程为守护线程，否则反之，默认为false
守护线程用于后台记录操作日志、监控内存、垃圾回收等待等等

public class TestSetDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        // 设置为守护线程
        thread.setDaemon(true); // 默认为false
        thread.start();
        new Thread(you).start(); // 用户线程
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("-----上帝守着你-----");
        }
    }
}

class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Happy Every Day");
        }
    }
}

结果：

-----上帝守着你-----
-----上帝守着你-----
-----上帝守着你-----
-----上帝守着你-----
-----上帝守着你-----
-----上帝守着你-----
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
Happy Every Day
-----上帝守着你-----
-----上帝守着你-----
-----上帝守着你-----
-----上帝守着你-----
...

参考: https://www.runoob.com/java/java-multithreading.html.

流水伊旧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java线程执行方法_java线程的常用方法
weixin_42300040的博客
02-20 1988
java线程的常用方法编号方法说明1public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。2public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。3public final void setName(String name)改变线程...
【JAVA基础--多线程中常用的方法】
大龄烤红薯的博客
08-23 807
线程中的常见方法
java多线程
好先生的博客
06-15 166
1.Java 多线程编程 Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到...
java多线程实现的常用两种方法
kuangsonghan的博客
12-20 5227
作为或即将成为一名Java工程师，在工作和面试中必然要与多线程打交道，那么Java中的多线程是什么呢？我们先来聊一聊操作系统中的进程和线程 1.进程和线程 1.1进程和线程的区别 进程简单来说就是操作系统中的一个任务，可以说是程序的执行，比如说你的电脑正在运行QQ和微信，那么这两个任务就是两个进程。而线程呢，是进程中不可或缺的一部分，一个进程中包含1-n个线程。两者比较官方的区别就是：
C++多线程获取返回值方法详解
12-17
但是在C++11 多线程中我们注意到，std::thread对象会忽略顶层函数的返回值。 那问题来了，我们要怎么获得线程的返回值呢？ 我们通过一个例子来说明如何实现这个需求。用多个线程计算（a+b）/ (x+y) 的值 有两种方法...
C# 多线程详解Thread
11-17
多线程的好处在于可以提高CPU 的利用率——任何一个程序员都不希望自己的程序很多 时候没事可干，在多线程程序中，一个线程必须等待的时候，CPU 可以运行其它的线程而不是 等待，这样就大大提高了程序的效率。
java多线程设计模式详解(PDF及源码)
07-14
单线程程序 多线程程序 Thread类的run方法和start方法 线程的启动 线程的启动（1）——利用Thread类的子类 线程的启动（2）——利用Runnable接口 线程的暂时停止 线程的共享互斥 synchronized方法 synchronized阻挡 ...
Java多线程详解
10-29
Java多线程模式详解 目录： 一、漫谈UML Java语言的线程 多线程的评量标准 二、 1、Single Threaded Execution ———— 能通过这座桥的，只有一个人 2、Immutable ———— 想破坏它也没办法 3、Guarded ...
JAVA入门1.2.3：一个老鸟的JAVA学习心得 PART1（共3个）
05-07
第7章 Java中的方法——给汽车丰富多彩的功能 154 教学视频：2小时55分钟 7.1 方法：让汽车动开动 154 7.1.1 引出问题：开动汽车 154 7.1.2 那么，方法到底是什么呢？ 155 7.1.3 方法调用过程初探 156 7.2 ...
【多线程】Thread类常用方法说明
Evan_QB的博客
03-30 331
①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）②join():指等待线程终止。join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了主线程才能执行。为什么要用join()方法在很多情况...
Java学习(十九)：多线程编程
qq_36212439的博客
09-28 188
Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束...
Java多线程编程
weixin_42031162的博客
04-05 107
Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。 这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行...
多线程常见方法及使用
myjess’s blog
03-02 594
常用方法 sleep 与 yield sleep 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞） 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException异常 @Slf4j(topic = "c.TestInterrupt") public class TestInterrupt { public static void main(String[] args) thro
多线程常用方法比较汇总
I'm Sure
11-15 101
从操作系统的角度讲，os会维护一个ready queue（就绪的线程队列）。并且在某一时刻cpu只为ready queue中位于队列头部的线程服务。 但是[u]当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。[/u]（这是yield的使用目的） 或者当前正在被服务的线程需要睡一会，醒来后继续被服务，这就是sleep。 sleep方法不推荐使用，可用wa...
线程的几种常用方法
Xiayubing_的博客
06-26 921
sleep()方法属于Thread类，主要的作用是让当前线程停止执行，把cpu让给其他线程执行，但不会释放对象锁和监控的状态，到了指定时间后线程又会自动恢复运行状态wait()方法属于Object类，与sleep()的区别是当前线程会释放锁，进入等待此对象的等待锁定池。比方说，线程A调用Obj.wait(),线程A就会停止运行，而转为等待状态。至于等待多长时间? 那就看其他线程是否调用Obj.no...
多线程常用方法
weixin_30299539的博客
06-02 65
1、sleep() 使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。 例如有 两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有 Sleep()方法，只有高优先级的...
Java 学习（五）—— 线程
TD520314的博客
05-25 251
一、线程的基本概念       1.线程是一个程序内部的顺序控制流。    2.线程和进程的区别         ① 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会消耗比较大的开销。例如，手机中的app进程；        ② 线程是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小；        ③ 多进程：操作系统中同时运行...
java中多线程的常用方法
最新发布
07-28
回答: 在Java中，创建多线程有几种常用的方法。其中一种方法是继承Thread类并重写其run()方法。通过创建一个继承自Thread类的子类，并在子类中重写run()方法来定义线程的执行逻辑。然后可以通过创建该子类的实例并...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值