java线程(三)

最新推荐文章于 2024-05-03 16:12:22 发布

祈蹊

最新推荐文章于 2024-05-03 16:12:22 发布

阅读量128

点赞数

分类专栏： java基础文章标签： java thread

本文链接：https://blog.csdn.net/weixin_43562107/article/details/104734604

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

java线程二

1.5 线程状态

在这里插入图片描述

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	指定毫秒数内让线程休眠
void join()	等待线程终止
static void yield()	暂停正在执行的线程,运行其他线程
void interrupt()	中断线程,不建议使用
boollean isAlive()	检测线程是否处于活动状态,不建议使用

1.5.1 停止线程

package com.gong.state;

/*
不推荐使用JDK提供的stop()、destroy()方法。[ 已废弃]
推荐线程自己停止下来
建议使用一一个标志位进行终止变量
当flag=false,则终止线程运行。
 */
public class ThreadStopTest  implements Runnable{
    //设置一个标志位
    private boolean flag = true;
    @Override
    public void run() {
        while(flag){
            int i = 1;
            System.out.println("run....Thread"+i++);
        }
    }

    //设置一个标志位停止线程,转换标志位
    public void stop(){
       flag = false;
    }

    public static void main(String[] args) {
        ThreadStopTest threadStopTest = new ThreadStopTest();
        new Thread(threadStopTest).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main....."+i);
            if(i == 900){
                //调用stop方法切换标志位,停止线程
                threadStopTest.stop();
                System.out.println("线程停止了");
            }
        }

    }
}

1.5.2 线程休眠(_sleep)

sleep (时间)指定当前线程阻塞的毫秒数;
sleep存在异常InterruptedException; .
sleep时间达到后线程进入就绪状态;
sleep可以模拟网络延时，倒计时等。
每一个对象都有一个锁, sleep不会释放锁;

package com.gong.state;

import com.gong.dome.ThreadConcurrent;
//模拟网络延时:放大问题的发生性
public class ThreadSleepTset implements Runnable{
    //票数
    private int ticket = 10;
    public static void main(String[] args) {
        ThreadConcurrent threadConcurrent = new ThreadConcurrent();
        new Thread(threadConcurrent,"学生").start();
        new Thread(threadConcurrent,"老师").start();
        new Thread(threadConcurrent,"黄牛").start();
    }

    @Override
    public void run() {
        while(true){
            if (ticket<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticket--+"票");
        }
    }
}

package com.gong.state;

//模拟倒计时
public class ThreadSleepTest2 {
    public static void main(String[] args) {
        tenDwon();
                //系统时间打印
//        Date dateTime = new Date(System.currentTimeMillis());//获取系统当前时间
//        while(true) {
//            try {
//                Thread.sleep(1000);
//                System.out.println(new SimpleDateFormat("HH:mm:ss").format(dateTime));//更改时间格式
//                dateTime = new Date(System.currentTimeMillis());//更新系统当前时间
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
    }
    public static void tenDwon(){
        int num = 10;
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }
}

1.5.3 线程礼让(_yield)

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度,礼让不-定成功!(a,b线程,a线程礼让,但不一定跑b线程,看cpu心情)

package com.gong.state;


public class ThreadYieldTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        new Thread(myThread,"a").start();
        new Thread(myThread,"b").start();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始运行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止运行");
    }
}

1.5.4 线程强制插队(_join)

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
可以想象成插队

package com.gong.state;

public class ThreadJoinTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程插队来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadJoinTest threadJoinTest = new ThreadJoinTest();
        Thread thread =new Thread(threadJoinTest);
        thread.start();
        for (int i = 0; i < 100; i++) {
            if(i==50){
                thread.join();
            }
            System.out.println("main...."+i);
        }
    }
}

1.5.5线程状态查看

**Thread.State:**线程状态。

线程可以处于以下状态之一:

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

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

package com.gong.state;

//观察线程状态
public class TreadState {
    public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread(()->{
           for (int i = 0; i < 5; i++) {
               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);//run

        while(state != Thread.State.TERMINATED){//只要线程不终止,就一直输出状态
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }

    }
}

1.6线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度
器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10.
- Thread.MIN_ PRIORITY= 1;
- Thread.MAX_ PRIORITY= 10;
- Thread.NORM_ _PRIORITY= 5;
使用以下方式改变或获取优先级
- getPriority() . setPriority(int xxx)

package com.gong.state;


public class ThreadPriority {
    public static void main(String[] args) {
        //main优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyThread1 myThread1 = new MyThread1();

        Thread t1 = new Thread(myThread1);
        Thread t2 = new Thread(myThread1);
        Thread t3 = new Thread(myThread1);
        Thread t4 = new Thread(myThread1);
        Thread t5 = new Thread(myThread1);

        //设置优先级,在启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(5);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();

        t5.setPriority(Thread.MIN_PRIORITY);//1
        t5.start();


    }

}

class MyThread1 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

1.7守护线程(Daemon)

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如:后台记录操作日志，监控内存，垃圾回收等待…

package com.gong.state;

public class ThreadDaemon {
    public static void main(String[] args) {
        Thread thread = new Thread(new God());
        thread.setDaemon(true);//默认是false表示为用户线程

        thread.start();//守护线程启动

        new Thread(new 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 < 100; i++) {
            System.out.println("你开心的活了"+i+"年");
        }
        System.out.println("you are die");
    }
}

java线程四

祈蹊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java线程(三)

java线程一java线程二1.5 线程状态方法说明setPriority(int newPriority)更改线程的优先级static void sleep(long millis)指定毫秒数内让线程休眠void join()等待线程终止static void yield()暂停正在执行的线程,运行其他线程void int...
复制链接

扫一扫