前面几篇文章为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 {
/**
* 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 {
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){
......
threadA.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){
......
threadA.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. 参考文章
903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
