Thread常用方法的使用(二)

原创

两个蝴蝶飞 2022-11-10 14:01:51 博主文章分类：Java多线程 ©著作权

文章标签 Thread Thread的join方法 Thread的yield方法多线程的interrupt 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者两个蝴蝶飞的原创作品，请联系作者获取转载授权，否则将追究法律责任

勿以恶小而为之，勿以善小而不为--------------------------刘备
劝诸君，多行善事积福报，莫作恶

上一章简单介绍了 Thread和Runnable实现多线程(一),如果没有看过，请观看上一章

一. Thread 的静态优先级常量

一.一静态常量

静态常量	值
MAX_PRIORITY	最大优先级,值为10
MIN_PRIORITY	最小优先级，值为1
NORM_PRIORITY	默认优先级，值为5

一. 二演示优先级常量

@Test
    public void staticTest(){

        System.out.println("max:"+Thread.MAX_PRIORITY);
        System.out.println("norm:"+Thread.NORM_PRIORITY);
        System.out.println("min:"+Thread.MIN_PRIORITY);
    }

运行测试，查看控制台:

Thread常用方法的使用(二)_Thread的yield方法

二. Thread 中方法

二.一构造方法

二.一.一方法

方法	作用
Thread()	默认，线程的名称系统自定义
Thread(String name)	用户传入唯一的线程名称
Thread(Runnable target)	传入 runnable对象
Thread(Runnable target, String name)	传入runnable对象和唯一线程名称name

二.一.二演示构造方法

@Test
    public void conTest(){

        //空构造
       Thread thread=new Thread();

        //传入名称 
        Thread thread1=new Thread("自定义线程");

        //传入Runnable

        Thread thread2=new Thread(new MyRunnable());
        //4 传入Runnable 和name


        Thread thread3=new Thread(new MyRunnable(),"自定义Runnable接口");
    }

二.二其他方法

方法	作用
static Thread currentThread()	获取当前的运行线程
void setName(String name)	设置线程的名称，一般在线程运行之前设置
String getName()	获取线程的名称
void setPriority(int newPriority)	设置线程的优先级
int getPriority()	获取线程的优先级
Thread.State getState()	获取线程的状态
boolean isAlive()	判断线程是否还活着
void setDaemon(boolean on)	设置是否是守护线程，必须在未start 之前设置
boolean isDaemon()	是否是守护线程
void interrupt()	中断线程
static boolean interrupted()	线程是否已经中断
boolean isInterrupted()	是否被中断
void join()	让此线程获取资源，强制运行
static void sleep(long millis)	优眠，单位是毫秒
void start()	开启
static void yield()	线程释放资源，不首先运行

三. 演示线程名称 getName()

@Test
    public void nameTest() throws Exception{

        NameThread nameThread=new NameThread();

        Thread thread1=new Thread(nameThread);

        //默认的为 Thread-接下来的数据， 从0开始。

        Thread thread2=new Thread(nameThread,"自定义线程");

        Thread thread3=new Thread(nameThread);

        Thread thread4=new Thread(nameThread,"两个蝴蝶飞，你好");
        thread1.start();

        thread2.start();
        thread3.start();

        thread4.start();
        
        // main,  main方法也是一个线程

        System.out.println("当前线程的名称:"+Thread.currentThread().getName());
    }

    class NameThread implements  Runnable{

        @Override
        public void run() {
            for(int i=0;i<5;i++){
                System.out.println("当前线程:"+Thread.currentThread().getName()+"正在运行，输出:"+i);
            }
        }
    }

运行程序，控制台打印输出

Thread常用方法的使用(二)_Thread的join方法_02

如果不传入线程的名称，则线程的名称系统自分配为: Thread-不重复数字

四. 获取线程的信息

四.一主线程状态

@Test
    public void readMainTest() throws Exception{

        //1. 获取当前的主线程

        Thread thread=Thread.currentThread();

        System.out.println("当前线程的名称:"+thread.getName());

        System.out.println("获取标识符 id:"+thread.getId());

        System.out.println("获取优先级:"+thread.getPriority());

        System.out.println("获取状态:"+thread.getState());

        System.out.println("当前线程是否还活着:"+thread.isAlive());

        System.out.println("是否被中断:"+thread.isInterrupted());

        System.out.println("是否是守护线程:"+thread.isDaemon());

        //可以手动设置名称和优先级

        thread.setName("手动设置名称");

        thread.setPriority(Thread.MAX_PRIORITY);

        System.out.println("当前线程的名称:"+thread.getName());

        System.out.println("获取优先级:"+thread.getPriority());

        //设置守护线程，必须要在线程运行之前进行设置  

    }

运行程序，看控制台输出:

Thread常用方法的使用(二)_Thread的yield方法_03

四.二 Runnable 线程状态

@Test
    public void readNoTest() throws Exception{

        ReadRunnable readRunnable=new ReadRunnable();

        Thread thread=new Thread(readRunnable);

        thread.start();

    }

    class ReadRunnable implements  Runnable{
        @Override
        public void run() {
            Thread thread=Thread.currentThread();

            System.out.println("当前线程的名称:"+thread.getName());

            System.out.println("获取标识符 id:"+thread.getId());

            System.out.println("获取优先级:"+thread.getPriority());

            System.out.println("获取状态:"+thread.getState());

            System.out.println("当前线程是否还活着:"+thread.isAlive());

            System.out.println("是否被中断:"+thread.isInterrupted());

            System.out.println("是否是守护线程:"+thread.isDaemon());

            //可以手动设置名称和优先级

            thread.setName("手动设置名称");

            thread.setPriority(Thread.MAX_PRIORITY);
            

            System.out.println("当前线程的名称:"+thread.getName());

            System.out.println("获取优先级:"+thread.getPriority());

        }
    }

运行程序，控制台打印输出:

Thread常用方法的使用(二)_多线程的interrupt_04

五. 守护线程 setDaemon()

守护线程指的就是，即使 Main 线程结束了，此线程仍然会继续运行。

五.一设置守护线程

@Test
    public void read3Test() throws Exception{

        Read3Runnable readRunnable=new Read3Runnable();

        Thread thread=new Thread(readRunnable);

        System.out.println("判断是否启动:"+thread.isAlive());

        System.out.println("是否是守护线程:"+thread.isDaemon());

        //在开启之前设置
        thread.setDaemon(true);


        thread.start();

        System.out.println("是否启动:"+thread.isAlive());

        System.out.println("是否是守护线程:"+thread.isDaemon());
    }


    class Read3Runnable implements  Runnable{
        @Override
        public void run() {
            System.out.println("获取线程的名称:"+Thread.currentThread().getName());
        }
    }

运行程序，控制台打印输出:

Thread常用方法的使用(二)_多线程的interrupt_05

五.二守护线程

@Test
    public void daemonTest() throws Exception{

        DaemonRunnable daemonRunnable=new DaemonRunnable();

        Thread thread=new Thread(daemonRunnable);

        //先不是守护线程

        //启动
       // thread.setDaemon(true);
        thread.start();



    }

   static class DaemonRunnable implements  Runnable{
        @Override
        public void run() {

            //死循环，会一直执行。 
            for(;;){
                System.out.println("我扣");
            }
        }
    }

此时运行, ，则运行一段时间之后，结束运行

Thread常用方法的使用(二)_Thread_06

如果将注释去掉，设置成守护线程的话，则会一直打印输出。

Thread常用方法的使用(二)_Thread_07

六. 线程的状态 State

线程的状态有以下几种:

NEW 尚未启动的线程处于此状态。
RUNNABLE 在Java虚拟机中执行的线程处于此状态。
BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED 已退出的线程处于此状态。

@Test
    public void readStateTest() throws Exception{

        ReadStateRunnable readRunnable=new ReadStateRunnable();

        Thread thread=new Thread(readRunnable);

         Thread.State state=thread.getState();

        System.out.println("开启前状态:"+state);

        thread.start();

        state=thread.getState();

        System.out.println("开启后状态:"+state);


    }


    class ReadStateRunnable implements  Runnable{
        @Override
        public void run() {
            System.out.println("获取线程的名称:"+Thread.currentThread().getName());
        }
    }

运行程序，控制台打印输出:

Thread常用方法的使用(二)_Thread_08

七. 线程优眠 sleep

会暂停时间。

//线程的休眠

    @Test
    public void sleepTest(){
        SleepRunnable readRunnable=new SleepRunnable();

        Thread thread=new Thread(readRunnable);

        thread.start();

        //休眠5秒， 保证后面的先不执行。
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("休眠结束，运行成功");


    }
    class SleepRunnable implements  Runnable{

        @Override
        public void run() {

            try {
                //暂时3秒后才输出内容。
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("输出线程名称:"+Thread.currentThread().getName());
        }
    }

Thread常用方法的使用(二)_Thread的yield方法_09

八. 线程的强制执行 join()

让这个线程强制最先执行。

//线程的 join 方法
    @Test
    public void joinTest() throws Exception{

        JoinRunnable joinRunnable=new JoinRunnable();

        Thread thread=new Thread(joinRunnable);

        //启动
        thread.start();

        // 主线程有10个，副线程100个，按理是 main先执行完， 加入了 join之后，强制让副线程先执行完。
        for(int i=0;i<10;i++){

            //让当前线程死掉.

            if(i==8){
                //当运行8后， 让 thread线程强制运行，即到 i=8了，不运行了，让 其他线程运行了。
                // 保证 i=8,i=9 最后输出。
                thread.join();
            }
            System.out.println("当前线程:"+Thread.currentThread().getName()+"运行到:"+i);
        }
    }


    class JoinRunnable implements  Runnable{
        @Override
        public void run() {

            for(int i=0;i<100;i++){
                System.out.println("输出内容:"+Thread.currentThread().getName()+",运行到:"+i);
            }
        }
    }

运行程序，查看控制台输出:

Thread常用方法的使用(二)_Thread的join方法_10

九. 线程的暂时挂起，不执行 yield()

注意， yield() 方法，只是让此线程释放资源，不执行，但不能保证最后执行。可以线程 i=8时，得到了资源，然后判断了i>=7, 执行 .yield() 方法，释放资源，忽然它又得到了资源，那么i=8 就会运行了。不像 join()那样强制。

@Test
    public void yieldTest() throws Exception{

        YieldRunnable yieldRunnable=new YieldRunnable();

        Thread thread=new Thread(yieldRunnable);

        //启动
        thread.start();

        for(int i=0;i<100;i++){
            System.out.println("当前线程:"+Thread.currentThread().getName()+"运行到:"+i);
        }
    }


    class YieldRunnable implements  Runnable{
        @Override
        public void run() {
            Thread thread=Thread.currentThread();
            for(int i=0;i<10;i++){
                if(i>=7){
                    //级别设置小点， 让其不执行。
                    thread.setPriority(Thread.MIN_PRIORITY);
                    Thread.yield();
                }
                System.out.println("输出内容:"+thread.getName()+",运行到:"+i);
            }
        }
    }

运行程序，查看控制台输出

Thread常用方法的使用(二)_Thread_11

这儿的 i=7,i=8,i=9 就得到了资源，执行了，而不是强制最后执行。

十. 打断休眠 interrupt()

主要用于打断休眠。

@Test
    public void interTest() throws Exception{

        InterruptRunnable interruptRunnable=new InterruptRunnable();

        Thread thread=new Thread(interruptRunnable);

        //启动

        thread.start();

        //休眠两秒
        Thread.sleep(2000);

        //两秒之后，进行打断， 副线程应该还在休眠的状态上。
        thread.interrupt();

        Thread.sleep(5000);

    }

    class InterruptRunnable implements  Runnable{
        @Override
        public void run() {

            System.out.println("开始进行休眠");

            try {
                Thread.sleep(5000);

                System.out.println("休眠结束");
            } catch (InterruptedException e) {
                System.out.println("休眠被打断");
            }

            System.out.println("退出休眠");
        }
    }

运行程序，

Thread常用方法的使用(二)_Thread_12

十.一设置停止和重启

以前是有 stop() 这样的方法的，后来被抛弃了，用标志位进行设置关闭和启动。

class MyRunnableDemo implements Runnable{
    private boolean isRun=true;
    @Override
    public void run() {
        //定义此标识位
            while(isRun){
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("打印输出");
            }
    }

    //通过标识位进行相应的控制
    public void stop(){
        this.isRun=false;
    }

    public void restart(){
        this.isRun=true;
        run();
    }
}
public class StopDemo {

    public static void main(String[] args) {
        MyRunnableDemo myRunnableDemo=new MyRunnableDemo();

        Thread thread=new Thread(myRunnableDemo);

        System.out.println("开始启动");
        thread.start();

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

        myRunnableDemo.stop();
        System.out.println("停止");

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("重新启动");
        myRunnableDemo.restart();

    }
}

运行程序，查看控制台。

Thread常用方法的使用(二)_Thread_13

这就是 Thread 类的常用方法，必须要掌握使用。

谢谢您的观看，如果喜欢，请关注我，再次感谢 !!!

上一篇：字节流InputStream和OutputStream(二)

下一篇：Quartz的重要接口API(二)

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯