Java Thread类简述

今天我们来看下java.lang.Thread这个类。

在学习Thread类之前,先看下线程相关知识:线程的几种状态、上下文切换,然后介绍Thread类中的方法的具体使用。

1、线程的状态

线程从创建到最终的消亡,要经历若干个状态。一般来说,线程包括以下这几个状态:创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡(dead)

当需要新起一个线程来执行某个子任务时,就创建了一个线程。但是线程创建之后,不会立即进入就绪状态,因为线程的运行需要一些条件(比如内存资源,我们知道程序计数器、Java栈、本地方法栈都是线程私有的,所以需要为线程分配一定的内存空间),只有线程运行需要的所有条件满足了,才进入就绪状态。

当线程进入就绪状态后,不代表立刻就能获取CPU执行时间,也许此时CPU正在执行其他的事情,因此它要等待。当得到CPU执行时间之后,线程便真正进入运行状态。

线程在运行状态过程中,可能有多个原因导致当前线程不继续运行下去,比如用户主动让线程睡眠(睡眠一定的时间之后再重新执行)、用户主动让线程等待,或者被同步块给阻塞,此时就对应着多个状态:time waiting(睡眠或等待一定的的时间)、waiting(等待被唤醒)、blocked(阻塞)。

当由于突然中断或者子任务执行完毕,线程就会被消亡。

下面这副图描述了线程从创建到消亡之间的状态:
 在这里插入图片描述
在有些教程上将blocked、waiting、time waiting统称为阻塞状态,这个也是可以的,只不过这里我想将线程的状态和Java中的方法调用联系起来,所以将waiting和time waiting两个状态分离出来。

2、上下文切换

对于单核CPU来说,CPU在一个时刻只能运行一个线程,当在运行一个线程的过程中转去运行另外一个线程,这个叫做线程上下文切换(对于进程也是类似)。

由于可能当前线程的任务并没有执行完毕,所以在切换时需要保存线程的运行状态,以便下次重新切换回来时能够继续切换之前的状态运行。举个简单的例子:比如一个线程A正在读取一个文件的内容,正读到文件的一半,此时需要暂停线程A,转去执行线程B,当再次切换回来执行线程A的时候,我们不希望线程A又从文件的开头来读取。

因此需要记录线程A的运行状态,那么会记录哪些数据呢?因为下次恢复时需要知道在这之前当前线程已经执行到哪条指令了,所以需要记录程序计数器的值,另外比如说线程正在进行某个计算的时候被挂起了,那么下次继续执行的时候需要知道之前挂起时变量的值时多少,因此需要记录CPU寄存器的状态。所以一般来说,线程上下文切换过程中会记录程序计数器、CPU寄存器状态等数据

说简单点的:对于线程的上下文切换实际上就是存储和恢复CPU状态的过程,它使得线程执行能够从中断点恢复执行。

虽然多线程可以使得任务执行的效率得到提升,但是由于在线程切换时同样会带来一定的开销代价,并且多个线程会导致系统资源占用的增加,所以在进行多线程编程时要注意这些因素。

3、Thread类中的方法

java.lang.Thread类的源码:
在这里插入图片描述
Thread类实现了Runnable接口,在Thread类中,有一些比较关键的属性,比如name是表示Thread的名字,可以通过Thread类的构造器中的参数来指定线程名字,priority表示线程的优先级(最大值为10,最小值为1,默认值为5),daemon表示线程是否是守护线程,target表示要执行的任务。

下面是Thread类中常用的关系到线程运行状态的方法:

1)start方法

start()用来启动一个线程,当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要的资源。

2)run方法

run()方法是不需要用户来调用的,当通过start方法启动一个线程之后,当线程获得了CPU执行时间,便进入run方法体去执行具体的任务。注意,继承Thread类必须重写run方法,在run方法中定义具体要执行的任务。

3)sleep方法
sleep相当于让线程睡眠,交出CPU,让CPU去执行其他的任务。
但是有一点要非常注意,sleep方法不会释放锁,也就是说如果当前线程持有对某个对象的锁,则即使调用sleep方法,其他线程也无法访问这个对象。看下面这个例子就清楚了:

public class Test {

	private int i = 0;
    private Object object = new Object();
     
    public static void main(String[] args) throws IOException  {
        Test test = new Test();
        MyThread t1 = test.new MyThread();
        MyThread t2 = test.new MyThread();
        t1.start();
        t2.start();
    } 
     
     
    class MyThread extends Thread{
        @Override
        public void run() {
        	String name = Thread.currentThread().getName();
        	//对象锁
            synchronized (object) {
                i++;
                System.out.println("------线程:"+name+" i:"+i);
                try {
                    System.out.println("------线程:"+name+" 进入睡眠状态");
                    Thread.currentThread().sleep(10000);
                } catch (InterruptedException e) {
                    // TODO: handle exception
                }
                System.out.println("------线程:"+name+" 睡眠结束");
                i++;
                System.out.println("------线程:"+name+" i:"+i);
            }
        }
    }
}

输出结果:

------线程:Thread-0 i:1
------线程:Thread-0 进入睡眠状态
------线程:Thread-0 睡眠结束
------线程:Thread-0 i:2
------线程:Thread-1 i:3
------线程:Thread-1 进入睡眠状态
------线程:Thread-1 睡眠结束
------线程:Thread-1 i:4

从上面输出结果可以看出,当Thread-0进入睡眠状态之后,Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后,此时Thread-0释放了对象锁,Thread-1才开始执行。

注意,如果调用了sleep方法,必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后,不一定会立即得到执行,因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。

4)yield方法

调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。但是yield不能控制具体的交出CPU的时间。

注意,调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的。

网上有这种说法:yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会,是这样吗,看下面测试代码:

public class Test {
     
    public static void main(String[] args) throws IOException  {
        Test test = new Test();
        MyThread t1 = test.new MyThread("lili");
        MyThread t2 = test.new MyThread("lucy");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
    } 
    
    class MyThread extends Thread{
    	private String name;
    	
    	public MyThread(String name) {
    		this.name = name;
    	}
    	
        @Override
        public void run() {
        	for(int i=0; i<10; i++) {
        		if("lili".equals(name)) {
        			yield();
        		}
        		System.out.println("我是:" + name);
        	}
        }
    }
}

运行结果,可以看出高优先级和低优先级的线程是交替执行的。高优先级线程调用yield方法后,只是让出了cpu,从运行状态转换成了就绪状态。至于之后谁能得到cpu时间,所有线程都有可能得到,只不过高优先级的线程概率大点。

我是:lucy
我是:lucy
我是:lucy
我是:lili
我是:lili
我是:lucy
我是:lili
我是:lucy
我是:lili
我是:lili
我是:lili
我是:lili
我是:lili
我是:lucy
我是:lucy
我是:lucy
我是:lucy
我是:lucy
我是:lili
我是:lili

5)join方法
假如在main线程中,调用thread.join方法,则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法,则等待thread执行完毕,如果调用的是指定了时间参数的join方法,则等待一定的时间。
看下面一个例子:

public class Test {

	public static void main(String[] args) throws IOException {
		String threadName = Thread.currentThread().getName();
		System.out.println("------线程:" + threadName + " 开始");
		MyThread t1 = new Test().new MyThread();
		t1.start();
		try {
			System.out.println("------线程:" + threadName + " 等待");
			t1.join();
			System.out.println("------线程:" + threadName + " 继续执行");
		} catch (InterruptedException e) {
		}
		System.out.println("------线程:" + threadName + " 结束");
	}

	class MyThread extends Thread {
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			System.out.println("------线程:" + threadName + " 开始");
			try {
				sleep(5000);
			} catch (InterruptedException e) {
			}
			System.out.println("------线程:" + threadName + " 结束");
		}
	}
}

运行结果:

------线程:main 开始
------线程:main 等待
------线程:Thread-0 开始
------线程:Thread-0 结束
------线程:main 继续执行
------线程:main 结束

可以看出,当调用t1.join()方法后,main线程会进入等待,然后等待t1执行完之后再继续执行。

实际上调用join方法是调用了Object的wait方法,这个可以通过查看源码得知,wait方法会让线程进入阻塞状态,并且会释放线程占有的锁,并交出CPU执行权限。
在这里插入图片描述
6)interrupt方法

interrupt,顾名思义,即中断的意思。单独调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常,也就说,它可以用来中断一个正处于阻塞状态的线程;另外,通过interrupt方法和isInterrupted()方法来停止正在运行的线程。
下面看一个例子:

public class Test {

	public static void main(String[] args) throws IOException  {
        Test test = new Test();
        MyThread t = test.new MyThread();
        t.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {
        }
        t.interrupt();
    } 
     
    class MyThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println("------小白要睡觉觉了");
                Thread.currentThread().sleep(10000);
                System.out.println("------小白睡醒了");
            } catch (InterruptedException e) {
                System.out.println("------小白被叫醒了");
            }
            System.out.println("------再见");
        }
    }
}

输出结果:

------小白要睡觉觉了
------小白被叫醒了
------再见

从这里可以看出,通过interrupt方法可以中断处于阻塞状态的线程。那么能不能中断处于非阻塞状态的线程呢?看下面这个例子:

public class Test {

	public static void main(String[] args) throws IOException {
		MyThread t = new Test().new MyThread();
		t.start();
		try {
			Thread.currentThread().sleep(200);
		} catch (InterruptedException e) {
		}
		t.interrupt();
	}

	class MyThread extends Thread {
		private static final int maxCount = 10000;
		@Override
		public void run() {
			int i = 0;
			while (i < maxCount) {
				i++;
				System.out.println("小白跑完了第 "+i+" 圈");
			}
		}
	}
}

运行后看输出结果,可以得出:直接调用interrupt方法不能中断正在运行中的线程。

但是如果配合isInterrupted()能够中断正在运行的线程,因为调用interrupt方法相当于将中断标志位置为true,那么可以通过调用isInterrupted()判断中断标志是否被置位来中断线程的执行。
将上面代码 while (i < maxCount) 改为:while (!isInterrupted() && i < maxCount)再次测试,可以看到运行结果没到10000次就结束了。

但是一般情况下不建议通过这种方式来中断线程,一般会在MyThread类中增加一个属性 isStop来标志是否结束while循环,然后再在while循环中判断isStop的值。

class MyThread extends Thread{
   private volatile boolean isStop = false;
    @Override
    public void run() {
        int i = 0;
        while(!isStop){
            i++;
        }
    }
     
    public void setStop(boolean stop){
        this.isStop = stop;
    }
}

上面介绍了Thread类中的大部分方法,那么Thread类中的方法调用到底会引起线程状态发生怎样的变化呢?看下图:
在这里插入图片描述
欢迎小伙伴们留言交流~~
浏览更多文章可关注微信公众号:diggkr

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页