Java多线程概念基础篇
引言
多线程是Java的一个重要主体之一，接下来将要讲解Java多线程篇章，涉及到的是JUC即java.util.concurrent包，该包是由Java大师 Doug Lea完成并且于JDK1.5之后并入到java中。我很欢迎读者在讨论区留言，也很乐意为入门的学者充当布道人，有问题就尽管提问吧。
一、线程的基本概念
线程的状态图大致如下：
分为以下5种状态：
- 新建状态(New): 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
- 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
- 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态
- 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
(01) 等待阻塞 – 通过调用线程的wait()方法，让线程等待某工作的完成。
(02) 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
(03) 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。 - 死亡状态(Dead) : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
以上的这5种状态涉及到的内容包括Object类, Thread和synchronized关键字。这些内容我们会在后面的章节中逐个进行学习。
- Object类，定义了wait(), notify(), notifyAll()等休眠/唤醒函数。
- Thread类，定义了一些列的线程操作函数。例如，sleep()休眠函数, interrupt()中断函数, getName()获取线程名称等。
- synchronized，是关键字；它区分为synchronized代码块和synchronized方法。synchronized的作用是让线程获取对象的同步锁。
在后面详细介绍wait(),notify()等方法时，我们会分析为什么“wait(), notify()等方法要定义在Object类，而不是Thread类中”。
二、实现多线程的方式
在Java中，实现多线程的方式总的来说分为两种，一种是通过继承Thread自定义自己的线程类，另外一种是通过实现Runnable等接口。以下简单贴个demo：
- 通过继承线程类：
public class MyThread extends Thread {
@Override
public void run() {
System.out.println(Math.random());
}
public static void main(String[] args) {
new MyThread().start();
}
}
- 通过实现Runnable接口创建线程：
public static void main(String[] args) {
Runnable target=()->{
System.out.println(Math.random());
};
new Thread(target).start();
}
- 通过实现Callable接口创建线程：
public static void main(String[] args) throws Exception{
Callable<String> callable = () -> {
System.err.println("我是返回值的run方法！");
Thread.sleep(10000);
return "我是回调对象";
};
FutureTask<String> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
System.out.println("***********等待************");
while (true){
//每1S检测是否完成？
Thread.sleep(1000);
System.out.println("未完成，执行检查...");
if (futureTask.isDone()){
System.out.println("**********完成************");
System.out.println(futureTask.get());
break;
}
}
System.out.println("结束");
}
对以上三种实现多线程方式做一个总结：
- 继承Thread、实现Runable、实现Callable接口，都可以创建线程，其中Callable接口需要使用FutureTask封装。
- 把Runable和Callable归纳为一类，继承Thread为一类，个人建议用实现接口的方式，因为可读性好，简便，并且复用性更强。
那么，JAVA是怎么实现线程的呢？接下来就以上述的demo做一个简单的剖析。
首先，我们查看Thread线程类的源码：
//我会列出线程类中的与上述demo相关的方法或者变量，来探究线程是怎么运行的
public class Thread implements Runnable {
/* 要运行的东西 */
private Runnable target;
//线程状态内部枚举类
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
//线程内部的run方法
@Override
public void run() {
if (target != null) {
//就是调用Runnable的run方法体。
target.run();
}
}
public synchronized void start() {
/**
*主方法线程或“系统”不调用此方法
*/
if (threadStatus != 0)
//threadStatus=0，即该线程是新创建的线程，处于NEW状态
throw new IllegalThreadStateException();
/* 通知组此线程即将启动
*以便可以将其添加到组的线程列表中
*该组的未启动计数可以减少。 */
group.add(this);
//定义是否执行完成的局部变量started
boolean started = false;
try {
//调用JVM实现的方法
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
private native void start0();
...
}
通过以上源码，我们可以知道，多线程的实现纵然可以继承Thread重写run方法，亦或者实现Runnable接口等，实质上殊途同归，都是封装到当前的run方法体当中去，并且交由JVM管理。大致的流程如下：
创建线程->修改runnable成员变量||重写run方法->执行start方法，实质交由start0，交由JVM创建线程执行。
通过如上的讲解，我想读者应该能够比较容易理解线程的创建，当然，对于Thread类的讲解，后续会有专门的篇章。在刚才的探究中，我们也看到了多线程模型中，start()与run()是不一致的。前者是创建新线程来运行指定的run方法体，后者是当前线程直接调用run方法执行。
三、总结
- 线程分为5种状态：NEW 、RUNNABLE 、RUNNING 、BLOCKED、 DEAD
- 线程创建的方式多种多样，但实际殊途同归
由于本篇是基础篇章，内容也相对简单，暂告一段落。
