JAVA多线程——线程状态和线程方法

线程状态

创建状态：Thread t = new Thread ()
就绪状态：调用start()方法，线程立即进入就绪状态，但不立即调度执行
运行状态：通过CPU进行调度执行，线程才执行线程体的代码块
阻塞状态：调用sleep，wait或同步锁定时，进入阻塞状态，阻塞状态解除后，线程重新进入就绪状态，等待CPU调度

死亡状态：一旦进入死亡状态，就不能再次启动

package com.peng.demon05;
//观察线程状态
public class TestStatus {
      
      

    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);



        }
    }
}

线程方法

setPriority(int newPriority) 更改线程的优先级

static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠

void join() 线程插队

static void yield() 暂停当前正在执行的线程对象，并执行其他线程

void interrupt() 中断这个线程（不推荐使用）

boolean isAlive() 测试线程是否处于活动状态

停止线程

不推荐使用JDK提供的stop()、destroy()方法

推荐让线程自己停下来，建议使用一个标志位进行终止变量，当flag=false，则终止线程运行

package com.peng.demon04;
/*测试停止线程
* 建议线程正常停止，利用次数（运行多少次后，线程自动停止），不建议死循环
* 设置一个标识位flag
* 不推荐使用JDK提供的stop()、destroy()方法过时的方法
* */
public class TestStop implements Runnable{
    
    
    //1，设置一个标志位
    private boolean flag = true;
    
    @Override
    public void run() {
    
    
        //线程体
        int i = 0;
        while (flag){
    
    //while (flag)=while (flag==true)
            System.out.println("run......Thread"+i++);
        }
    }
    //2,设置一个公开的方法停止线程，
    public void stop1(){
    
    
        //转换标志位
        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"+i);
            if (i==900){
    
    //i到900时，TestStop线程停止，但main线程依然执行
                //通过调用stop1方法来切换标志位，停止线程
                testStop.stop1();
                System.out.println("线程要停止了");
            }
        }
    }
}

在这里插入图片描述

线程休眠

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

模拟网络延时

package com.peng.demon04;

import com.peng.demon01.TestThread04;

/*模拟网络延时
提高问题的发生性，让代码的问题可见
* */
public class TestSleep implements Runnable{
    
    
    //票数
    private int ticketNums = 10;
    @Override
    public void run() {
    
    
        while (true){
    
    //如果买到了票
            if (ticketNums<=0){
    
    
                break;//如果没票了就退出
            }
            //模拟延时
            try {
    
    
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }

            //               通过这个方法获得当前执行线程的名字
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
        }
    }
    public static void main(String[] args) {
    
    
        //创建Runnable实现类的对象
        
        TestSleep ticket = new TestSleep();
        //开启多个线程
        new Thread(ticket,"狂铁").start();
        new Thread(ticket,"后羿").start();
        new Thread(ticket,"达摩").start();
    }
}

在这里插入图片描述

模拟倒计时

package com.peng.demon04;


import java.text.SimpleDateFormat;
import java.util.Date;

/*模拟倒计时
*
* */
public class TestSleep2 {
    
    
    public static void main(String[] args) {
    
    

        try {
    
    
            tenDown();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
    }
        //倒计时方法
    public static void tenDown() throws InterruptedException {
    
    
        int num = 10;
        
        while (true){
    
    
            Thread.sleep(1000);//一秒走一下
            System.out.println(num--);
            if (num==0){
    
    
                break;
            }
        }
    }

}

在这里插入图片描述

打印系统当前时间

package com.peng.demon04;


import java.text.SimpleDateFormat;
import java.util.Date;


public class TestSleep2 {
    
    
    public static void main(String[] args) {
    
    
        
        //打印系统当前时间
        Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间

        while (true){
    
    
            try {
    
    
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
    
}

在这里插入图片描述

线程礼让

暂停当前正在执行的线程对象，将线程从运行状态变为就绪状态，并执行其他线程，但不阻塞

礼让不一定成功，还是要看CPU的调度

package com.peng.demon04;
//测试线程礼让
public class TestYield {
    
    
    public static void main(String[] args) {
    
    
        MyYield myYield = new MyYield();
        new Thread(myYield, "a").start();
        new Thread(myYield, "b").start();
    }
}
class MyYield implements Runnable{
    
    

    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程插队

join()方法，待此线程执行完成，再执行其他线程，其他线程阻塞

package com.peng.demon04;

import javax.swing.*;

//测试join方法
public class TestJoin implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for (int i = 1; i <= 300; 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 = 1; i <= 500; i++) {
    
    
            if (i==100){
    
    //i=100时,就去执行TestJoin线程
                thread.join();
            }
            System.out.println("main线程执行"+i);
        }

    }
}

在这里插入图片描述

线程优先级

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都要看CPU的调度

package com.peng.demon04;
//测试线程的优先级
public class TestPriority {
    
    
    public static void main(String[] args) {
    
    
        //打印主线程的优先级
        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);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        t1.start();//默认是5
        //先设置优先级，再启动
        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

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

class MyPriority implements Runnable{
    
    


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

在这里插入图片描述