学习笔记-java线程基础

本文内容源于视频教程，若有侵权，请联系作者删除

 

一、线程生命周期

1.1 线程的六种状态

初始状态：线程被创建

运行状态：JAVA线程把操作系统中的就绪和运行两种状态统一称为“运行中” 

阻塞状态：由于某种原因导致正在运行的线程让出CPU执行权限

等待状态：等待完成返回

超时等待状态：超时以后自动返回

终止状态：线程执行完毕或者被其他线程杀死。

 1.1 查看线程状态

public class ThreadStatusDemo {
    
    public static void main(String[] args) {
        new Thread(()->{
            while (true){
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "sleep_thread").start();

        new Thread(()->{
            while (true){
                synchronized (ThreadStatusDemo.class) {
                    try {
                        ThreadStatusDemo.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "wait_thread").start();

        BlockDemo blockDemo = new BlockDemo();
        new Thread(new BlockDemo(),"线程A").start();
        new Thread(new BlockDemo(),"线程B").start();
    }

    static class BlockDemo extends Thread{
        @Override
        public void run() {
            synchronized (BlockDemo.class){
                try {
                    Thread.sleep(110000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

打开terminal->输入jps命令，复制当前类的执行线程id->输入jstack 线程id查看当前进程中各线程状态。

1.2 启动和终止线程

1.2.1 启动线程

调用Thread.start()

1.2.2 线程中断

Thread.interrupt()优雅地中断线程。

public class InterruptDemo {
    private static int i = 0;

    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            while (!Thread.interrupted()){
                i++;
            }
            System.out.println("i=" + i);
        });
        thread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
    }
}

每个线程都有一个中断标识，为了更好地理解，假设该变量为boolean isInterrupted=false 标识当前线程没有被中断，而调用Thread.interrupt()方法实质上就是将isInterrupted设置为true。具体细节可以通过hotspot源码看到。

1.2.2 线程复位

第一种方法：Thread.interrupted()

public class InterruptedDemo {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            while (true){
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("before interrupted :" + Thread.currentThread().isInterrupted());
                    Thread.interrupted();
                    System.out.println("after interrupted :" + Thread.currentThread().isInterrupted());
                }
            }
        });
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

输出结果

before interrupted :true
after interrupted :false

由此可见，Thread.interrupted()的作用实质上是设置isInterrupted为false

第二种方法：throw InterruptedException

public class ExceptionThreadDemo {

    private static int i = 0;

    public static void main(String[] args) {

        Thread thread = new Thread(() -> {
            while (!Thread.interrupted()) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("i=" + i);
        });
        thread.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
        System.out.println(thread.isInterrupted());
    }
}