线程实现及创建方式

public enum State {
    /**
     * Thread state for a thread which has not yet started.
     * 初始状态，线程被构建，但是还没有调用start()方法
     */
    NEW,

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     * 运行状态，Java线程将操作系统中的就绪和运行状态笼统的称作：运行中
     *
     */
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
   	 * 阻塞状态，表示线程阻塞于锁
     */
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     * 等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其它线程做出一些特定的动作
     *(通知或中断)
     */
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     * 超时等待状态，该状态不同于WAITING，它是可以在指定时间自行返回的
     *
     */
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     * 终止状态，表示当前线程已经执行完毕
     */
    TERMINATED;
}

public class TestThread {
    
    public static void main(String[] args) {

        Thread thread = new Thread(new ThreadDemo());
        thread.start();
    }

    static class ThreadDemo extends Thread{
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }
}

@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 class ImplRunnable {

    public static void main(String[] args) {
        //静态代理的方式实现线程
        new Thread(()-> System.out.println("Impl Runnable Thread")).start();
    }

}

 
public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
}

public Thread(Runnable target, String name) {
        init(null, target, name, 0);
}

// ⽚段1 - init⽅法
private void init(ThreadGroup g, Runnable target, String name,long stackSize,AccessControlContext acc,boolean inheritThreadLocals)
    
// ⽚段2 - 构造函数调⽤init⽅法
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

// ⽚段3 - 使⽤在init⽅法⾥初始化AccessControlContext类型的私有属性
this.inheritedAccessControlContext = acc != null ? acc : AccessController.getContext();

// ⽚段4 - 两个对⽤于⽀持ThreadLocal的私有属性
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

@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 ImplCallable implements Callable<String> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public String call() throws Exception {
        return "Impl Callable";
    }

    public static void main(String[] args) {
        //这里是演示使用该方法，正常情况下是不允许的
        ExecutorService executorService = Executors.newCachedThreadPool();
        ImplCallable implCallable = new ImplCallable();
        Future<String> submit = executorService.submit(implCallable);
        System.out.println(submit.get());
        executorService.shutdown();
    }
}

/**
* 运行结果：
* Impl Callable
*/

public interface Future<V> {

   	//试图取消一个线程的执行，返回是否取消成功
    boolean cancel(boolean mayInterruptIfRunning);
    //判断当前方法是否取消
    boolean isCancelled();
	//判断当前方法是否完成
    boolean isDone();
  	//当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕
    V get() throws InterruptedException, ExecutionException;
    //多等待timeout的时间就会返回结果
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

/**
 * Future和ExecutorService搭配使用
 * 运行程序的主机是12线程的，因此启动了12个线程，每次会同时执行12个task。
 *
 */
public class TestFuture {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //匿名内部类声明
        Callable<Long> callable = new Callable<Long>() {
            @Override
            public Long call() throws Exception {

                long start = System.currentTimeMillis();
                Thread.sleep(100);
                long end = System.currentTimeMillis();

                long seed = end - start;
                System.out.println(Thread.currentThread().getName()+" seed=" + seed);

                return seed;
            }
        };
        List<Callable<Long>> tasks = new ArrayList<>();
        //循环添加24次
        for(int i = 0; i < 24; i++) {
            tasks.add(callable);
        } 
		//判断计算机的线程
        int poolSize = Runtime.getRuntime().availableProcessors();
        System.out.println("poolSize=" + poolSize);
        ExecutorService executorService = Executors.newFixedThreadPool(poolSize);
        List<Future<Long>> futures = executorService.invokeAll(tasks);

        long result = 0;
        for (Future<Long> future : futures) {
            result += future.get();
        }
        System.out.println("result=" + result);

        executorService.shutdown();
    }
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue);

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory);

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler);

//⽤给定的初始参数创建⼀个新的ThreadPoolExecutor。以上3个构造方法都是建立在这个基础上
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler);

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
       // 1.当前线程数⼩于corePoolSize,则调⽤addWorker创建核⼼线程执行任务
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
           		 return;
            c = ctl.get();
        }
        // 2.如果不⼩于corePoolSize，则将任务添加到workQueue队列。
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执行饱和策略。
            if (! isRunning(recheck) && remove(command))
           		reject(command);
            // 2.2 线程池处于running状态，但是没有线程，则创建线程
            else if (workerCountOf(recheck) == 0)
            	addWorker(null, false);
        }
        // 3.如果放⼊workQueue失败，则创建非核⼼线程执⾏任务，
        // 如果这时创建非核⼼线程失败(当前线程总数不⼩于maximumPoolSize时)，就会执行饱和策略。
        else if (!addWorker(command, false))
        	reject(command);
    }

public class ThreadPoolExecutorDemo {

    // 最大核心线程数
    public static final int CORE_POOL_SIZE = 5;
    // 最大线程数
    public static final int MAXINUM_POOL_SIZE = 10;
    // 最大队列长度
    public static final int QUEUE_CAPACITY = 100;
    // 非核心线程闲置超时时间
    public static final Long KEEP_ALIVE_TIME = 1L;

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE,
                MAXINUM_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        //1. 线程总数量 < corePoolSize，无论线程是否空闲，都会新建一个核心线程执行
        //任务（让核心线程数量快速达到corePoolSize，在核心线程数量 <corePoolSize时）。
        // 注意，这一步需要获得全局锁。
        
        //2. 线程总数量 >= corePoolSize时，新来的线程任务会进入任务队列中等待，然
        //后空闲的核心线程会依次去缓存队列中取任务来执行（体现了线程复用）。
        
        //3. 当缓存队列满了，说明这个时候任务已经多到爆棚，需要一些“临时工”来执行
        //这些任务了。于是会创建非核心线程去执行这个任务。注意，这一步需要获得
        //全局锁。
        
        //4. 缓存队列满了， 且总线程数达到了maximumPoolSize，则会采取上面提到的
        //饱和策略进行处理。
        //最大任务数
        int maxTask = 1000;
        for (int i = 0; i < maxTask; i++) {
           Runnable task = ()->{
                    System.out.println(Thread.currentThread().getName() + " Start.Time = " +new SimpleDateFormat("HH:mm:ss").format(new Date()));
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " End.Time = " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            };
            
            // 执行Runnable
            executor.execute(task);
        }
        executor.shutdown();
    }
}