14.3多线程常用操作方法

最新推荐文章于 2025-03-13 14:40:10 发布
最新推荐文章于 2025-03-13 14:40:10 发布
阅读量280 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zyhhkb/article/details/124597507
版权

3.1 线程的命名和取得

        线程本身属于不可见的运行状态，即每次操作的时间都是无法预料的，所以如果要想在程序中操作线程，唯一依靠的就是线程名称，而要想取得和设置线程的名称可以使用如表所示的方法。

由于多线程的状态不确定，线程的名字就成为唯一的分辨标记，所以在定义线程名称的时候一定要在线程启动前设置名字，而且尽量不要重名，尽量不要为已经启动的线程修改名字。

由于线程的状态不确定，所以每次可以操作的都是正在执行run()方法的线程实例，依靠Thread类的以下方法实现。

取得当前线程对象: public static Thread currentThread()

范例：观察线程的命名操作

package cn.kuiba.util;

class MyThread implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());   //当前线程名称
    }
}
public class Main {
    public static void main(String[] args){
        MyThread mt=new MyThread();
        new Thread(mt,"线程A").start();                    //设置了线程的名字
        new Thread(mt).start();                                 //未设置线程名字
        new Thread(mt,"线程B").start();                    //设置了线程的名字
    }
}



程序执行结果：
线程A(线程手动命名)
线程B(线程手动命名)
Thread-0(线程自动命名)

        通过本程序可知，如果已经为线程设置名字的话，那么会使用用户定义的名字;而如果没有设置线程名称，系统会自动为其分配一个名称，名称的形式以“Thread-xxx”的方式出现。

提示：关于线程名称的自动命名。

        在第5章讲解static关键字的时候曾经提到过一个统计实例化对象个数与成员属性自动命名的操作，实际上Thread对象的自动命名形式与之类似，下面截取了Thread类的部分源代码。

public class Thread{
    private static int threadInitNumber;                //记录线程初始化个数
    public Thread(Runnable target){
        init(null,target,"Thread-"+nextThreadNum(),0);  //线程自动命名
    }
    public Thread(Runnable target,String name){
        init(null,target,name,0);                       //线程手动命名
    }
    private static synchronized int nextThreadNum(){
        return threadInitNumber++;                      //线程对象个数增长
    }
}

        通过源代码可以发现，每当实例化Thread类对象时都会调用init()方法，并且在没有为线程设置名称时自动为其命名。

        所有的线程都是在程序启动后在主方法中进行启动的，所以主方法本身也属于一个线程，而这样的线程就称为主线程，下面通过一段代码来观察主线程的存在。

package cn.kuiba.util;

class MyThread implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());   //获取线程名称
    }
}
public class Main {
    public static void main(String[] args){
        MyThread  mt =new MyThread();                           //线程类对象
        new Thread(mt,"线程对象").start();                 //设置了线程的名字
        mt.run();                                               //对象直接调用run()方法
    }
}


程序执行结果：
main（主程序，mt.run()执行结果）
线程对象（子线程）

        本程序在主方法中直接利用线程实例化对象调用了run()方法，这样所获取到的对象就是main线程对象。

提示：所有的线程都是在进程的基础上划分的，当用户使用Java命令执行一个类的时候就表示启动了一个JVM的进程，而主方法是在这个进程上的一个线程而已，而当一个类执行完毕后，此进程会自动消失。

        通过以上分析就可以发现实际开发中所有的子线程都是通过主线程来创建的，这样的处理机制主要是可以利用多线程来实现一些资源耗费较多的复杂业务，如图。

         通过如图可以发现，当程序中存在多线程机制后，就可以将一些耗费时间和资源较多的操作交由子线程处理，这样就不会因为执行速度而影响主线程的执行。

范例：子线程处理复杂逻辑

package cn.kuiba.util;

public class Main {
    public static void main(String[] args) throws Exception{
        System.out.println("1、执行操作任务一。");       //主线程执行
        new Thread(()->{                             //子线程负责统计
            int temp=0;
            for (int x=0;x<Integer.MAX_VALUE;x++){
                temp +=x;                           //【模拟】执行耗时操作
            }
        }).start();
        System.out.println("2、执行操作任务二。");       //主线程执行
        System.out.println("3、执行操作任务三。");       //主线程执行
    }
}

        本程序启动了一个子线程进行耗时的业务处理，在子线程的执行过程中，主线程中的其他代码将不会受到该耗时任务的影响。

3.2 线程休眠

        当一个线程启动后会按照既定的结构快速执行完毕，如果需要暂缓线程的执行速度，就可以利用Thread类中提供的休眠方法完成，该方法定义如表。

        在进行休眠的时候有可能会产生中断异常InterruptionException，中断异常属于Exception的子类，程序中必须强制性进行该异常的捕获与处理。

范例：线程休眠 

package cn.kuiba.util;

public class Main {
    public static void main(String[] args) throws Exception{
        Runnable runnable=()->{                    //Runnable接口实例
            for (int x=0;x<10;x++){
                System.out.println(Thread.currentThread().getName()+"、x="+x);
                try {
                    Thread.sleep(1000);            //暂缓1秒（1000毫秒）执行
                }catch (InterruptedException e){   //强制性异常处理
                    e.printStackTrace();
                }
            }
        };
        for (int num=0;num<5;num++){
            new Thread(runnable,"线程对象-"+num).start();    //启动线程
        }
    }
}

        本程序设计了5个线程对象，并且每一个线程对象执行时都需要暂停1秒。但是，多线程的启动与执行都是由操作系统随机分配的，虽然看起来这5个线程的休眠是同时进行的，但是也有先后顺序，只不过速度较快，不宜观察。

3.3 线程中断

        在Thread类提供的线程操作方法中很多都会抛出InterruptionException中断异常，所以线程在执行过程中也可以被另外一个线程中断执行，线程中断的操作方法如表。

 范例：线程中断操作

package cn.kuiba.util;

public class Main {
    public static void main(String[] args) throws Exception{
        Thread thread=new Thread(()->{
            System.out.println("【BEFORE】准备睡觉10秒钟的时间，不要打扰我！！");
            try {
                Thread.sleep(10000);            //预计准备休眠10秒
                System.out.println("【FINISH】睡醒了，开始学习和工作！");
            }catch (InterruptedException e){
                System.out.println("【EXCEPTION】睡觉被打扰了，坏脾气爆发！");
            }
        });
        thread.start();                    //线程启动
        Thread.sleep(10000);               //保证子线程先运行1秒
        if (!thread.isInterrupted()){      //该线程中断？
            System.out.println("【INTERRUPT】敲锣打鼓地路过你睡觉的地方！");
            thread.interrupt();            //中断执行
        }
    }
}


程序执行结果：
【BEFORE】准备睡觉10秒钟的时间，不要打扰我！！
【INTERRUPT】敲锣打鼓地路过你睡觉的地方！
【EXCEPTION】睡觉被打扰了，坏脾气爆发！

        本程序实现了线程执行的中断操作，可以发现线程的中断是被动完成的，每当被中断执行后就会产生InterruptionException异常。

3.4 线程强制执行

        在多线程并发执行中每一个线程对象都会交替执行，如果此时某个线程对象需要优先执行完成，则可以设置为强制执行，待其执行完毕后其他线程再继续执行，Thread类定义的线程强制执行方法如下。

线程强制执行：public final void join() throws InterruptionException

范例：线程强制执行

package cn.kuiba.util;

public class Main {
    public static void main(String[] args) throws Exception{
        Thread mainThread= Thread.currentThread();              //获得主线程
        Thread thread=new Thread(()->{
            for (int x=0;x<100;x++){
                if (x==3){                                      //设置强制执行条件
                    try {
                        mainThread.join();                      //强制执行线程任务
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(100);                     //延缓执行
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"执行、x="+x);
            }
        },"玩耍的线程");
        thread.start();
        for (int x=0;x<100;x++){                                //主线程
            Thread.sleep(100);
            System.out.println("【霸道的main线程】number="+x);
        }
    }
}

        本程序启动了两个线程：main线程和子线程，在不满足强制执行条件时，两个线程会交替执行，而当满足了强制执行条件(x==3)时会在主线程执行完毕后再继续执行子线程中的代码。

3.5 线程礼让

        线程礼让是指当满足某些条件时，可以将当前的调度让给其他线程执行，自己再等待下次调度再执行，方法定义如下。

线程礼让：public static void yield()

范例：线程礼让

package cn.kuiba.util;

public class Main {
    public static void main(String[] args) throws Exception{
        Thread thread=new Thread(()->{
            for (int x=0;x<100;x++){
                if (x%3==0){
                    Thread.yield();                     //线程礼让
                    System.out.println("【YIELD】线程礼让，"+Thread.currentThread().getName());
                }
                try {
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"执行、x="+x);
            }
        },"玩耍的线程");
        thread.start();
        for (int x=0;x<100;x++){
            Thread.sleep(100);
            System.out.println("【霸道的main线程】number="+x);
        }
    }
}



程序执行结果(截取部分随机结果)：
【YIELD】线程礼让，玩耍的线程
玩耍的线程执行、x=0
【霸道的main线程】number=0
玩耍的线程执行、x=1
【霸道的main线程】number=1
玩耍的线程执行、x=2
【霸道的main线程】number=2
【YIELD】线程礼让，玩耍的线程
【霸道的main线程】number=3
玩耍的线程执行、x=3
玩耍的线程执行、x=4
【霸道的main线程】number=4
玩耍的线程执行、x=5
【霸道的main线程】number=5
【YIELD】线程礼让，玩耍的线程
【霸道的main线程】number=6

        在多线程正常执行中，原本的线程应该交替执行，但是由于礼让的关系，会出现某一个线程暂时让出调度资源的情况，让其他线程优先调度。

3.6 线程优先级

        在Java的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时会根据线程的优先级进行资源调度，即哪个线程的优先级高，哪个线程就有可能会先被执行，如图。

         如果想要进行线程优先级的设置，在Thread类中有以下支持的方法及常量，如表。

 范例：观察线程优先级

package cn.kuiba.util;

public class Main {
    public static void main(String[] args) throws Exception{
        Runnable run =()->{                                         //线程类对象
            for (int x=0;x<10;x++){
                try {
                    Thread.sleep(1000);                         //暂缓执行
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"执行。");
            }
        };
        Thread threadA=new Thread(run,"线程对象A");             //线程对象
        Thread threadB=new Thread(run,"线程对象B");
        Thread threadC=new Thread(run,"线程对象C");
        threadA.setPriority(Thread.MIN_PRIORITY);                   //修改线程优先级
        threadB.setPriority(Thread.MIN_PRIORITY);
        threadC.setPriority(Thread.MAX_PRIORITY);
        threadA.start();                                            //线程启动
        threadB.start();
        threadC.start();
    }
}

        本程序为线程设置了不同的优先级，理论上讲优先级越高的线程越有可能先抢占资源。（主方法的优先级对应的是中等优先级。）

荒诞硬汉
关注
Auto.js找图找色常用功能
越陌度阡
08-07 7341
1. 颜色的表示方法 颜色表示方式一："#AARRGGBB"，需要表示透明度的时候用这种方法。 颜色表示方式二："#RRGGBB"，不需要表示透明度的时候用这种方法。 AA 是Alpha通道（透明度）的值； RR 是R通道（红色）的值； GG 是G通道（绿色）的值； BB 是B通道（蓝色）的值； 2. 颜色的转换方法 1. 返回颜色值的字符串； 2. 返回颜色的整数值； .....................
Java基础面试题02（多线程面试题（JUC面试题），注解和反射面试题，异常面试题，网络编程面试题）
weixin_45929082的博客
09-13 695
1.多线程 1.什么是线程和进程? 何为进程? 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。 如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。 何为线程? 线程与进程相似，但线程是一个比进程更小
关于多线程操作的几个方法
z123456789XDW的博客
10-15 650
虽然Thread类实现了Runnable接口，但是操作线程的主要方法并不在Runnable接口中，多线程操作，主要是通过Thread类中的方法实现。1线程的生命周期要想实...
多线程常用操作
sifanchao的博客
11-14 652
线程命名与取得 多线程的运行状态是不确定的，所以对于多线程操作必须有一个明确标识出线程对象的信息，这个信息往往通过名称来描述。在Thread类中提供有如下的线程名称方法： class MyThread implements Runnable { @Override public void run() {} } public class TestThread { publi...
【多线程】多线程基础操作
最新发布
m0_50534425的博客
03-13 668
想让线程结束，只需在 catch 中加上 break。当引入的线程到达一定数量后在尝试继续引入新的线程无法提升，当线程数量太多的时候，线程之间就会相互竞争CPU的资源(CPU核心数有限)非但不会提高效率，反而增加调度开销。操作系统进行"多任务调度"本质上是在调度PCB(线程在系统中的调度规则就和之前的进程是一样的,线程的PCB中也有状态,优先级,上下文,记账信息…5.每个线程，也是一个独立的执行流，可以执行一些代码，并且单独的参与到CPU调度中(状态,上下文,优先级,记账信息,每个线程都有自己的一份)
多线程操作
weixin_74744611的博客
02-08 964
一个代码在单线程或者多线程下执行都不会产生bug.这个情况就是"线程安全"的.但是代码如果在单线程下运行正确但是在多线程下很可能产生bug.这个情况就被称为"线程不安全"或者是"存在线程安全问题"i<50000;});i<50000;});t1.start();t2.start();t1.join();t2.join();
第14章 多线程编程.pdf
05-25
### 第14章 多线程编程 #### 14.1 线程的基本概念 ...以上总结了《第14章 多线程编程》中的关键知识点，包括线程的基本概念、操作方法以及同步机制。这些内容对于理解和掌握多线程编程至关重要。
Delphi 5开发指南：多线程、文件处理与系统移植
### 第11章 编写多线程应用程序 #### 11.1 对线程的解释 ##### 11.1.1 一种新型的多任务 多线程是一种新型的多任务处理方式，能够提高程序的执行效率。在多线程环境中，CPU可以在多个线程之间切换，使得程序能够...
JAVA面试题总结||——集合与线程
weixin_45441572的博客
12-11 691
1.1接口继承关系和实现: 集合存放于Java.util包中，主要有3种: set无序集合、list有序列表集合、map键值对映射。 1.Collection: Collection是集合List、Set、Queue的最基本的接口。 2.Iterator：迭代器，可以通过迭代器遍历集合中的数据。 3.Map：是映射表里的基础接口。
多线程的基本操作
2301_76692760的博客
10-30 199
主要讲解的是线程的基本操作,包括线程的创建,线程的中断,线程等待,线程休眠和一些Thread的其他属性
关于多线程
2402_83198714的博客
05-12 1002
Object类有个 notify方法，用于唤醒在此对象监视器上等待的一个线程,如果所有线程都在此对象上等待，则会选择唤醒其中一个线程,选择是任意的我们通常调用其中一个对象的 wait方法在对象的监视器上等待直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程，被唤醒的线程将以常规方式与在该对象上主动同步的其他线程竞争。join方法用于等待其他线程终止，如果在当前线程中调用一个线程的 join方法，则当前线程转为阻塞状态，等到另一个线程结束，当前线程再由阻塞状态转为就绪状态，等待获取CPU 的使用权。
多线程基本操作
思凡
07-10 274
1.创建线程的四种方式 1）继承Thread类创建线程 自定义线程类继承Thread类， 重写run()方法，编写线程执行体， 创建线程对象,调用start()方法启动线程 2）实现Runnable接口创建线程 自定义线程类实现Runnable接口 实现run()方法,编写线程执行体 创建线程对象,调用start()方法启动线程 3）使用Callable和Future创建线程 1.实现Callable接口，重写call()方法，创建该实现类的实例 2.使用FutureTask类来包装Callable
多线程的常见操作
lichong的博客
10-30 242
一.创建线程 在Android中，提供了两种创建线程的方法，一种是通过Thread类的构造方法创建线程，并重写run()方法，另一种是通过实现Runnable接口实现。下面分别进行介绍。 1.通过Thread类的构造方法创建线程 在Android中，可以使用Thread类提供的构造方法来创建线程 Thread(Runnable runnable); 该构造方法的参数runnable，可以
多线程的基本操作（1）
吃四碗饭的嘤嘤怪的博客
07-28 5427
线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 1、新建状态（New）：新创建了一个线程对象。2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因...
C++多线程操作
永不秃头的三三的博客
02-24 502
本文主要介绍了thread创建线程的相关知识点，方便日后自己回顾也希望能够帮助到大家，主要的内容包含了thread创建线程、互斥量mutex、条件变量condition_variable、aysnc创建线程以及原子操作等相关知识
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值