Multithreading

public class Thread implements Runnable

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

@FunctionalInterface
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;
}

public class CallableTest {

	public static void main(String[] args) throws ExecutionException, InterruptedException {
		Callable<Integer> callable = new Task();
		FutureTask task = new FutureTask(callable);

		Thread oneThread = new Thread(task);
		oneThread.start();

		System.out.println(">>>  工作结果 " + task.get().toString());
	}

}

class Task implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {
		System.out.println(">>>  线程开始工作");
		Thread.sleep(1000);
		System.out.println(">>>  结束工作开始返回");
		return 10;
	}

}

//使用这个构造方法
public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}

ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("test-%d").build();
ExecutorService service = new ThreadPoolExecutor(5, 200, 0L, TimeUnit.MILLISECONDS,
         new LinkedBlockingDeque<>(1024), factory, new ThreadPoolExecutor.AbortPolicy());

/**
  * corePoolSize：核心线程池的线程数量
  *　
  *　maximumPoolSize：最大的线程池线程数量
  *　
  *　keepAliveTime：线程活动保持时间，线程池的工作线程空闲后，保持存活的时间。
  *　
  *　unit：线程活动保持时间的单位。
  *　
  *　workQueue：指定任务队列所使用的阻塞队列
*/
//ThreadPoolExecutor#execute
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
　　 //由它可以获取到当前有效的线程数和线程池的状态
　　 /*1.获取当前正在运行线程数是否小于核心线程池，是则新创建一个线程执行任务，否则将任务放到任务队列中*/
　　 int c = ctl.get();
    if (workerCountOf(c) < corePoolSize){
        if (addWorker(command, tre))     //在addWorker中创建工作线程执行任务
            return ;
        c = ctl.get();
    }
    /*2.当前核心线程池中全部线程都在运行workerCountOf(c) >= corePoolSize，所以此时将线程放到任务队列中*/
    //线程池是否处于运行状态，且是否任务插入任务队列成功
    if (isRunning(c) && workQueue.offer(command))    {
        int recheck = ctl.get();
　　　　 if (!isRunning(recheck) && remove(command))//线程池是否处于运行状态，如果不是则使刚刚的任务出队
　　　　　　 reject(command);//抛出RejectedExceptionException异常
　　　　 else if (workerCountOf(recheck) == 0)
　　　　　　 addWorker(null, false);
　　}
    /*3.插入队列不成功，且当前线程数数量小于最大线程池数量，此时则创建新线程执行任务，创建失败抛出异常*/
　　else if (!addWorker(command, false)){
　　　　reject(command);    //抛出RejectedExceptionException异常
　　}
}

//ThreadPoolExecutor#addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
/*首先会再次检查线程池是否处于运行状态，核心线程池中是否还有空闲线程，都满足条件过后则会调用compareAndIncrementWorkerCount先将正在运行的线程数+1，数量自增成功则跳出循环，自增失败则继续从头继续循环*/
　　...
　　if (compareAndIncrementWorkerCount(c))
　　　　break retry;
　　...
　　/*正在运行的线程数自增成功后则将线程封装成工作线程Worker*/
　　boolean workerStarted = false;
　　boolean workerAdded = false;
　　Worker w = null;
　　try {
　　　　final ReentrantLock mainLock = this.mainLock;//全局锁
　　　　w = new Woker(firstTask);//将线程封装为Worker工作线程
　　　　final Thread t = w.thread;
　　　　if (t != null) {
　　　　　　//获取全局锁
　　　　　　mainLock.lock();
　　　　　　/*当持有了全局锁的时候，还需要再次检查线程池的运行状态等*/
　　　　　　try {
　　　　　　　　int c = clt.get();
　　　　　　　　int rs = runStateOf(c);        //线程池运行状态
　　　　　　　　if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)){　　　　　　　　　　//线程池处于运行状态，或者线程池关闭且任务线程为空
　　　　　　　　　　if (t.isAlive())    //线程处于活跃状态，即线程已经开始执行或者还未死亡，正确的应线程在这里应该是还未开始执行的
　　　　　　　　　　　　throw new IllegalThreadStateException();
　　　　　　　　　　//private final HashSet<Worker> wokers = new HashSet<Worker>();
　　　　　　　　　　//包含线程池中所有的工作线程，只有在获取了全局的时候才能访问它。将新构造的工作线程加入到工作线程集合中
　　　　　　　　　　workers.add(w);
　　　　　　　　　　int s = worker.size();    //工作线程数量
　　　　　　　　　　if (s > largestPoolSize)
　　　　　　　　　　　　largestPoolSize = s;
　　　　　　　　　　workerAdded = true;    //新构造的工作线程加入成功
　　　　　　　　}
　　　　　　} finally {
　　　　　　　　mainLock.unlock();
　　　　　　}
　 　　　　if (workerAdded) {
　　　　　　　　//在被构造为Worker工作线程，且被加入到工作线程集合中后，执行线程任务
　　　　　　　　//注意这里的start实际上执行Worker中run方法，所以接下来分析Worker的run方法
　　　　　　　　t.start();
　　　　　　　　workerStarted = true;
　　　　　　}
　　　　}
　　} finally {
　　　　if (!workerStarted)　　　//未能成功创建执行工作线程
　　　　　　//在启动工作线程失败后，将工作线程从集合中移除
　　　　　　addWorkerFailed(w);    
　　}
　　return workerStarted;
}

//ThreadPoolExecutor$Worker，它继承了AQS，同时实现了Runnable，所以它具备了这两者的所有特性
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
　　final Thread thread;
　　Runnable firstTask;
　　public Worker(Runnable firstTask) {
　　　　//设置AQS的同步状态为-1，禁止中断，直到调用runWorker
　　　　setState(-1);    
　　　　this.firstTask = firstTask;
　　　　//通过线程工厂来创建一个线程，将自身作为Runnable传递传递
　　　　this.thread = getThreadFactory().newThread(this);    
　　}
　　public void run() {
　　　　runWorker(this);    //运行工作线程
　　}
}