线程状态

Thread t = new Thread() 线程对象一旦创建就进入新生状态
调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行
当调用sleep wait或同步锁定时，线程进入阻塞状态。阻塞事件解除后，重新进入就绪状态，等待cpu调度执行。
进入运行状态，线程才真正执行线程体的代码块
线程中断或者结束，一旦进入死亡状态，就不能再次启动

线程方法

停止线程

使用一个标志位进行终止变量，当flag = false, 则终止线程运行
建议线程正常停止——>利用次数，不建议死循环
不建议使用stop、destory等过时的方法。

public class TestStop implements Runnable{
    //定义一个标识位
    private boolean flag = true;

    @Override
    public void run() {
        while(flag){
            System.out.println("线程运行");
        }
    }

    //提供一个结束线程的方法
    public void stop(){
        this.flag = false;
    }
}

线程休眠

sleep(时间)指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
每一个对象都有一个锁，sleep不会释放锁
模拟网络延时：放大问题的发生性；模拟倒计时

例子：每隔一秒打印一次系统时间

public class TestSleep{
    public static void main(String[] args) throws InterruptedException {
        Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true){
            Thread.sleep(1000);//每隔一秒打印一次时间;静态方法直接使用类名调用
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            startTime = new Date(System.currentTimeMillis());//更新系统当前时间
        }
    }
}

线程礼让yield

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行转为就绪
让cpu重新调度，礼让不一定成功！

public class TestYield {
    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();//static方法，直接用类名调用
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

礼让成功：

礼让失败：

线程强制执行 Join

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

public class TestJoin 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 {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 50; i++) {
            if(i == 25){
                thread.join();//主线程阻塞直到thread执行完
            }
            System.out.println("主线程执行——>"+i);
        }
    }
}

观测线程状态

线程可以处于以下状态之一，可以使用getState()方法：

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

public class TestState {
    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();
                }
            }
        });

        Thread.State state = thread.getState();//获取状态
        System.out.println(state);//NEW

        thread.start();
        state = thread.getState();
        System.out.println(state);//Runnable

        while(state !=Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10

Thread.MIN_PRIORITY = 1;

Thread.MAX_PRIORITY = 10;

Thread.NORM_PRIORITY = 5;
使用以下方法改变或获取优先级

getPriority() setPriority(int x)

示例：

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,"t1");
        Thread t2 = new Thread(myPriority,"t2");
        Thread t3 = new Thread(myPriority,"t3");
        Thread t4 = new Thread(myPriority,"t4");
        Thread t5 = new Thread(myPriority,"t5");
        Thread t6 = new Thread(myPriority,"t6");

        t1.start();//输出t1默认优先级 5

        t2.setPriority(Thread.MIN_PRIORITY);//最小优先级 1
        t2.start();

        t3.setPriority(3);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//最大优先级 10
        t4.start();

        t5.setPriority(7);
        t5.start();

        t6.setPriority(8);
        t6.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        //输出线程优先级
        System.out.println(Thread.currentThread().getName()+"——>"+Thread.currentThread().getPriority());
    }
}

运行结果：

注意：

优先级的设定建议在start()调度前；
优先级低只是意味着活得调度的概率低，并不是优先级低就不会被调用了，这都是看cpu的调度

守护线程（Daemon）

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

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        Thread godThread = new Thread(god);

        godThread.setDaemon(true);//设置为守护线程，默认为false
        godThread.start();

        new Thread(new You()).start();//启动用户线程
    }
}

class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 30000; i++) {
            System.out.println("你开心的活着");
        }
        System.out.println("======Goodbye World!=======");
    }
}

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

输出结果：用户线程执行完毕程序就结束

posted @ 2022-11-08 11:24 奚罗罗阅读(28) 评论(0) 收藏举报

刷新页面返回顶部

线程状态

线程状态

线程方法

停止线程

线程休眠

线程礼让yield

线程强制执行 Join

观测线程状态

线程优先级

守护线程（Daemon）

公告