[TOC]
一、继承Thread类
继承Thread类，重写run方法，调用Thread的start()方法启动线程：
/**
* 实现线程方式：1、继承Thread类
*/
@Slf4j
public static class ThreadTarget extends Thread {
@Override
public void run() {
while (true) {
log.info("Thread extentions: " + System.currentTimeMillis());
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
new一个Thread实例的时候，所有构造方法最终都是调用Thread的init方法， init方法中，设置线程属性，校验相关权限：
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc) {
/**设置线程名字,匿名线程，名字自动生成：Thread-nextThreadNum()**/
if (name == null) {
throw new NullPointerException("name cannot be null");
}
this.name = name;
/**设置线程组**/
Thread parent = currentThread();
SecurityManager security = System.getSecurityManager();
if (g == null) {
if (security != null) {
g = security.getThreadGroup();
}
if (g == null) {
g = parent.getThreadGroup();
}
}
g.checkAccess(); //检查当前线程(parent)是否有权限修改线程组g
if (security != null) { //校验是否thread子类的getContextClassLoader被覆盖
if (isCCLOverridden(getClass())) { //并且拥有enableContextClassLoaderOverride权限
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
}
g.addUnstarted(); //增加线程组的unstarted线程计数
this.group = g; //设置线程组
/**继承当前线程(parant)的是否后台线程、设置优先级的值**/
this.daemon = parent.isDaemon();
this.priority = parent.getPriority();
/**设置contextClassLoader和继承accessControlContext**/
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
/**设置Runnable接口的实例，作为target对象**/
this.target = target;
/**这里才是真正设置优先级的地方**/
setPriority(priority);
/**继承当前线程(parent)的ThreadLocal.ThreadLocalMap**/
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
this.stackSize = stackSize;
/**设置线程id, 这里设置的是tid，跟nextThreadNum()设置的threadInitNumber是两个值**/
tid = nextThreadID();
}
启动线程需要调用start方法，方法中调用native方法start0真正启动线程，
虚拟机会在线程启动过程中回调Thread的run方法：
public synchronized void start() {
/**threadStatus不等于0, 状态异常，非NEW状态的线程*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/**将线程加入到线程组，减线程组的unstarted计数器**/
group.add(this);
boolean started = false;
try {
/**native方法启动线程**/
start0();
started = true;
} finally {
try {
if (!started) {
/**移出线程组，增加unstarted计数器**/
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/** do nothing. start0的异常会直接抛出 **/
}
}
}
/**启动线程的native方法**/
private native void start0();
- Thread本身也实现了Runnable接口, 实现run方法，虚拟机启动时，调用的就是该实现方法。
- 单纯从target看，Thread和Runnable的关系看，这是简单的模板方法模式的实现。
- 这也引出了第二种实现方式，实现Runnable接口或者实现/继承Runnable接口的子接口/子类。
- 所以继承Thread实现run和实现Runnable接口实现run方法是有本质区别的，Thread的run是被虚拟机调用的，Runnable的run是作为thread的target属性的模板方法被调用的。
@Override
public void run() {
/**如果target不为空，调用target的run方法**/
if (target != null) {
target.run();
}
}
二、实现或继承Runnable接口的子接口或实现类
实现多线程的另外方式是实现或继承Runnable接口的子接口或实现类
1、继承Runnable接口
直接实现Runnable接口的问题是，线程执行完成后，无法获取到线程执行结果。
/**
* 实现线程方式： 2、实现Runnable接口
*/
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
log.info("Runnable implements 1: " + System.currentTimeMillis());
try {
Thread.sleep(200);
} catch (InterruptedException e) {
log.error(e.getMessage(), e);
}
}
}
});
thread2.start();
/**
* 实现线程方式： jdk1.8之后，可以更简单的写法
*/
Thread thread3 = new Thread(() -> {
while (true) {
log.info("Runnable implements 2: " + System.currentTimeMillis());
try {
Thread.sleep(200);
} catch (InterruptedException e) {
log.error(e.getMessage(), e);
}
}
});
thread3.start();
2、继承FutureTask接口
如果需要获取线程执行结果， 可以实现FutureTask接口, 并通过FutureTask的get方法获取执行结果：
/**
* 实现线程方式： 3、实现Callable接口，配合FutureTask，获取线程执行结果
*/
FutureTask<Integer> task = new FutureTask<>(new Fibonacci(10));
Thread thread4 = new Thread(task);
thread4.start();
try {
Integer result = task.get();
log.info("FutureTask result: {}" , result);
} catch (ExecutionException e) {
log.error(e.getMessage(), e);
}
FutureTask相关的源码研究，后续分析。
3、继承TimerTask接口
如果需要在主线程外执行一些任务的话，可以使用TimerTask接口,配合定时器工具Timer实现，Timer内部维护一个TimerThread线程，用于执行调度任务：
/**
* 实现线程方式：4、调度执行任务
*/
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
log.info("TimerTask execute: {}", System.currentTimeMillis());
}
}, 5000, 3000);
简单的应用可以使用Timer，复杂需求应该引入框架。
三、Executor框架
JDK1.5引入Executor异步执行框架，灵活强大，支持多种任务执行策略，将任务提交和执行解耦，可以通过submit和execute提交任务给线程池执行。Executors提供一系列创建线程池的工厂方法。
后续对Executor框架进行分析
/**
* 实现多线程的方式： 5、java.util.concurrent包提供的Executor框架,创建线程池，执行任务
*/
ExecutorService executorService = Executors.newFixedThreadPool(5);
//通过execute执行实现Runnable接口的任务
for(int i = 0; i < 100; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
log.info("ThreadPool execute task: {} {}",
Thread.currentThread().getName(),
System.currentTimeMillis());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
log.error(e.getMessage(), e);
}
}
});
}
//也可以通过submit实现Callable接口的任务，以便获取线程执行结果
Future<Integer> fiboResult = executorService.submit(new Fibonacci(10));
try {
log.info("ThreadPool submit task: {}",fiboResult.get());
} catch (ExecutionException e) {
log.error(e.getMessage(), e);
}
四、ForkJoin框架
如果大任务可以分解成小任务并行计算，可以实现RecursiveTask接口，提交到ForJoin框架执行。
public static void useForkJoinFramework() {
long start = System.currentTimeMillis();
ForkJoinPool pool = new ForkJoinPool();
Long result = pool.invoke(createNewTask(0L, 10000000000L, 1000000000L));
log.info("ForkJoinPool execute result: {} {}", result , (System.currentTimeMillis() - start));
start = System.currentTimeMillis();
long sum = 0;
for(long i = 0;i <= 10000000000L; i++) {
sum += i;
}
log.info("Simple sum: {} {}", sum, (System.currentTimeMillis() - start));
}
@SuppressWarnings("serial")
public static RecursiveTask<Long> createNewTask(final Long start, final Long end, final Long critical){
return new RecursiveTask<Long>() {
@Override
protected Long compute() {
if(end - start <= critical) {
long sum = 0L;
for(long l = start; l <= end; l++) {
sum += l;
}
return sum;
}else {
Long middle = (end + start) / 2;
RecursiveTask<Long> left = createNewTask(start, middle, critical);
RecursiveTask<Long> right = createNewTask(middle+1, end, critical);
left.fork();
right.fork();
return left.join()+right.join();
}
}
};
}
RecursiveTask接口继承自ForkJoinTask接口， ForkJoinTask继承Future接口。
五、总结
Java中多线程编程主要分两类：
- 通过创建Thread实例创建线程和start()方法启动线程，自己管理线程，执行任务；
- 通过Executor框架创建线程池，或者实现相关接口，通过线程池管理管理线程执行任务；
- 通过ForkJoin框架并行执行任务。
不管是通过哪种方式， 都有支持Runnable接口提交任务和支持Callable接口的方式，jdk1.8之后，还可以通过lambda表达式提交任务，
编程上弱化了Runnable和Callable的区别，所以选用哪种方式去创建线程和管理线程，取决于：
- 场景是否足够简单，只需简单管理线程，还是需要强大的线程管理功能？
- 是否需要线程执行结果，可以Future相关的API？
- 是否可以并行执行？
