前面几篇文章为Java多线程做足了铺垫,这篇终于到了正题,一起学习一下Java多线程的基础知识。
1. Java线程生命周期
下图表述了Java线程的几个基本状态:
- New新建状态:线程创建后即进入。
- Runnable就绪状态:调用线程的start方法后,线程不会立刻运行,而是进入就绪状态,等待CPU调度。
- Running运行状态: CPU开始调度处于就绪状态的线程后,线程进入运行状态。换言之,就绪状态是运行状态的唯一入口。
- Blocked阻塞状态:线程由于某种原因放弃CPU的使用权,停止执行,此时进入阻塞状态,一直到进入就绪态CPU才能对其进行重新调度。
产生Blocked状态的几种可能
等待阻塞:运行线程中的wait()方法,使本地线程进入阻塞状态。
同步阻塞:线程获取sychronized同步锁失败,进入同步阻塞状态。
其他阻塞:调用线程的sleep()或join()发出I/O请求,线程进入阻塞状态。当sleep()超时,join()等待线程终止或超时,处理完I/O时,线程重新进入就绪状态。
- Dead死亡状态:线程执行完毕或异常退出。该线程结束了生命周期。
2. Java线程实现方法
2.1. 继承Thread类,重写run()方法
最基本的线程方式,通过继承Thread类,重写run()方法即可运行子线程。缺点是Java类只能有一个父类,如果所要使用的类本身有其他需要继承的实体,就会比较麻烦。
class MyThread extends Thread {
private volatile boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
@Override
public void run() {
System.out.println("进入到run方法中了");
while (isRunning == true) {
}
System.out.println("线程执行完成了");//结束线程,进入dead态
}
}
public class RunThread{
public static void main(String[] args) {
try {
MyThread thread = new MyThread();//创建线程,进入new态
thread.start();//start线程,进入runnable态,CPU开始调度后进入running态
Thread.sleep(1000);//阻塞主线程,进入blocked态
thread.setRunning(false);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2.2. 实现Runnable接口,便于继承其他类
针对Thread类继承可能存在困难的问题,利用Java接口无限制的特性,利用接口来进行线程实现。在运行时,需要运行一个thread并把接入了Runnable的类以参数形式传给thread。
class MyClass implements Runnable {
private volatile boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
@Override
public void run() {
System.out.println("进入到run方法中了");
while (isRunning == true) {
}
System.out.println("线程执行完成了");
}
}
public class RunThread{
public static void main(String[] args) {
try {
MyClass myClass=new MyClass();
Thread thread=new Thread(myClass);
thread.start();
Thread.sleep(1000);
myClass.setRunning(false);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
我们需要知道的是,Thread类本身就已经接入了Runnable接口,如果我们给一个自定义的已经重写run的Thread类的子类A传入一个接入Runnable的类B作为参数,那么该子类A会运行类B的run()函数,原因为,Thread中的run()函数代码如下:
@Override
public void run() {
if (target != null) {
target.run();
}
}
可见,如果target存在,即有Runnable类的子类作为参数传递,则不运行Thread提供的run()方法。
最基本的Thread和Runnable有一个共同的问题,即是run()函数没有返回值,导致线程间交互会比较复杂,需要依赖引用的互相传递。因此,当需要有返回值时,Java提供了另外的类。
2.3. Callable类替换Runnable类,实现返回值
Callable接口定义如下:
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
对于Callablel类我们只需要知道以下几点
需要实现重写其call()函数来实现功能。
泛型的输入类型即是call()的返回类型。
实现了call函数,简单的把Callable接口替换Runnable接口,我们就可以实现简答的有返回值线程了,但Java提供了更多的线程状态检查,控制类来更好的使用这两个接口。
2.4. Future接口对任务进行监测
Future接口有5个方法,我们依次来进行介绍
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
- cancel() 方法来表示取消任务,如果取消成功则返回true,否则返回false。其参数mayInterruptIfRunning则表示正在执行的任务。
- isCanelled() 方法表示任务是否已经取消,如果任务完成前成功取消则返回true。
- isDone() 方法表示任务是否已经完成,如果完成返回true。
- get() 方法获取执行结果,这个方法会产生阻塞,一直到执行完毕才返回。
- get(long timeout, TimeUnit unit) 方法在获取执行结果同时给一个时间,如果超时仍被阻塞则返回Null。
2.5. FutureTask类:Future类的唯一实现
FutureTask类实现了RunnableFuture接口,而RunnableFuture接口如同名字一样,接入了Runnable和Future两个类。因此FutrueTask既可以作为Runnable被线程执行(自动调用其run()方法),同时又可以视为Future类来得到Callable类的返回值。此处我们可以看到Java设置这个类的用意——让用户尽量使用这个类去管理线程。
使用FutureTask类托管Callable的一个例子:
class MyClass implements Callable {
private volatile boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
@Override
public Object call() {
System.out.println("进入到run方法中了");
while (isRunning == true) {
}
System.out.println("线程执行完成了");
return isRunning;
}
}
public class RunThread{
public static void main(String[] args) {
try {
MyClass myClass=new MyClass();
FutureTask futureTask=new FutureTask(myClass);
Thread thread=new Thread(futureTask);
thread.start();
Thread.sleep(1000);
myClass.setRunning(false);
try{
System.out.println(futureTask.get());
}
catch (Exception e){
System.out.println("Type error");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3. Java多线程的调度
3.1. Java多线程的就绪,运行和死亡
如图,需要注意的是CPU调度线程有随机性,不排除线程调用yield()进入就绪状态后CPU又去调用线程的情况。
3.2. Java线程的阻塞
3.2.1. Java线程的阻塞方法
- join()方法:让一个线程等待另一个线程完成才继续执行。如,在线程A的运行过程中调用线程B的join方法,则线程A被阻塞,等待线程B运行完成后才继续运行。该方法通常用于主线程中。
public static void main(String[] args){
......
threadB.join();
}
- sleep()方法:让当前的线程进入阻塞状态,暂停指定时间,之后恢复就绪状态。例如,在前面的例子里,我们让主线程sleep 1000毫秒以显示效果。需要注意的是,sleep()方法并不会释放锁,实际上,sleep()是一个与实例无关的方法。sleep()方法是一个静态方法,也就是说他只对当前线程有效,通过t.sleep()让t对象进入sleep,这样的做法是错误的,其效果和Thread.sleep()无异但造成了一定迷惑性。sleep()的目的在于让当前线程自主的暂停,因而是针对当前线程生效的静态方法,即是在子线程的run()函数中也可以调用。如果不是这样的设计,sleep()要么和wait()同质,要么会造成严重的死锁。与sleep()方法有一定共性但实质上区别很大的wait()方法接下来我会单开文章去谈。
3.3. 后台线程
后台线程主要为其他线程提供服务,或“守护线程”。例如:JVM的GC线程。后台线程与前台线程生命周期有一定关联。主要体现在:当所有前台线程死去时,后台线程也会自动死去。
设置一个线程是否为后台线程只需要调用该线程的setDaemon(boolean val)方法即可,创建一个线程后,默认为非后台线程。
public static void main(String[] args){
......
threadB.setDaemon(true);
}
3.4. 线程的优先级
考虑到下面的情景,5个线程竞争同一资源,资源目前被重要线程A锁定,当线程A执行完毕,解锁释放资源后,我们希望重要线程E能先于BCD得到资源。此时,我们则需要优先级这个属性。每个线程都有一个优先级变量,该变量的值可以是1到10之间的一个常数。数字越大,代表优先级越高。Java给了其中三个常量名称,分别是:
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5
默认情况下,一个线程的优先级是其父线程的优先级。而主线程的优先级是NORM_PRIORITY,即数字5,因此,我们可以看到很多资料里认为现成的默认优先级是5,其实不是这样的。我们可以通过调用线程的setPrority(short val)来设置线程的优先级以及使用getPrority()来获取优先级。
class MyClass implements Callable {
@Override
public Object call() {
System.out.println("线程执行完成了,将返回其子线程的优先级");
return new Thread().getPriority();
}
}
public class RunThread {
public static void main(String[] args) {
FutureTask futureTask = new FutureTask(new MyClass());
Thread thread = new Thread(futureTask);
thread.setPriority(3);
System.out.println("设置该线程的优先级为"+thread.getPriority());
thread.start();
try {
System.out.println("该线程的子线程优先级为" + futureTask.get());
} catch (Exception e) {
System.out.println("Type error");
}
}
}
上面这段代码的返回内容如下:
设置该线程的优先级为3
线程执行完成了,将返回其子线程的优先级
该线程的子线程优先级为3
然而,需要注意的是,优先级无法保证线程的执行顺序,即在BCDE竞争资源的情境中,无法保证E线程一定先执行。优先级高则其获取CPU资源的可能性比较大,而不是一定会先于其他线程获取执行优先权,优先级低的线程仍有得到执行权的可能。
同时我们不要忘记,Java的Thread类的核心方法是native方法,即是线程实现大量依赖宿主机的机制。Java有10个优先级,如果宿主机是Linux系统,有31个优先级,显然没什么问题。但如果宿主机是Windows7,只有7个优先级,那么Java的10个优先级就会根据系统的优先级进行映射。同时,线程的优先级也会受到虚拟机的影响。
3.5. 线程让步yield()
前面多少也提到过了。yield()和sleep()类似,是静态方法,作用于将当前运行的线程,其作用于具体线程,调用方法是Thread.yield()
,使用t.yield()
同样是能够使用但逻辑不清晰的做法。具体来说。yield()是让当前线程从running态回到runnable态。之后,线程间重新进行资源竞争,由CPU进行调度,因此yield()实际上是一个与锁不是很有关系的方法,和sleep()一样,作为当前线程的主动方法,不会引起死锁。
4. 参考文章
Java并发编程:Callable,Future和FutureTask
[线程的状态、分类及优先级](http://blog.****.net/yegongheng/article/details/38708765