源码解析创建线程的四种方法

源码解析创建线程的四种方法

先剧透，实现线程的方式本质上只有一种，只是调用了不同的构造方法

继承 Thread 类

public class ExtendsThread extends Thread {

    @Override
    public void run() {
        System.out.println('继承Thread类实现的线程');
    }
    public static void main(String[] args) {
        new ExtendsThread().start();
    }
}

实现 Runnable 接口

public class RunnableThread implements Runnable {

    @Override
    public void run() {
        System.out.println('实现Runnable接口的线程');
    }

	public static void main(String[] args) {
        new Thread(RunnableThread).start();
    }
}

线程池创建线程

先看下线程池的七大默认参数：

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

其中的 Executors.defaultThreadFactory() 就是创建线程的默认工厂

Executors.clss

  public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }

static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);

这句才是真正创建线程的地方

不记得Thread构造函数的童鞋，可以康康片头

有返回值的 Callable 创建线程

这个创建方法有点绕了，请系好安全带

先看线程池架构图

支持 Callable 创建线程主要就是在ExecutorService中的submit方法

主要看其子类AbstractExecutorService的实现

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

public class FutureTask<V> implements RunnableFuture<V> {
	......
	}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

public interface Executor {
	// 所以可以执行 AbstractExecutorService.submit方法中的ftask
    void execute(Runnable command);
}