//...
class Xxx  implements Runnable{
    //...
        static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        //...
        lock.lock();
        try {
            //...
        } finally {
            lock.unlock();
        }
    }

}

        //...
        lock.lock();
        lock.lock();
        try {
            //...
        } finally {
            lock.unlock();
            lock.unlock();
        }

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Hello world!");
        Thread thread0 = new TempThread(0, "thread0");
        Thread thread1 = new TempThread(1, "thread1");
        thread0.start();
        thread1.start();
//        thread0.join();
//        thread1.join();
        Thread.sleep(2000);
        DeadLockChecker.checkAndStop();
    }
}

class TempThread extends Thread {
    int flag = 0;
    static ReentrantLock lock0 = new ReentrantLock();
    static ReentrantLock lock1 = new ReentrantLock();

    public TempThread(int flag) {
        this.flag = flag;
    }

    public TempThread(int flag, String name) {
        super(name);
        this.flag = flag;
    }

    @Override
    public void run() {
        try {
            //以下尝试构造一个死锁情况
            if (flag % 2 == 0) {
                //获取锁lock0
//                lock0.lock();
                lock0.lockInterruptibly();
                try {
                    //休眠500毫秒
                    try {
                        sleep(500);
                    } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
                        System.out.println(Thread.currentThread().getName() + " with flag: " + flag + " interrupted in sleep().");
                    }
                    //尝试获取另一个锁
//                    lock1.lock();
                    lock1.lockInterruptibly();
                    lock1.unlock();
                } finally {
                    //释放锁lock0
                    lock0.unlock();
                }
            }
            else {
                //获取锁lock1
//                lock1.lock();
                lock1.lockInterruptibly();
                try {
                    //休眠500毫秒
                    try {
                        sleep(500);
                    } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
                        System.out.println(Thread.currentThread().getName() + " with flag: " + flag + " interrupted in sleep().");
                    }
                    //尝试获取另一个锁
//                    lock0.lock();
                    lock0.lockInterruptibly();
                    lock0.unlock();
                } finally {
                    //释放锁lock1
                    lock1.unlock();
                }
            }
        } catch (InterruptedException exc) {
            System.out.println(Thread.currentThread().getName() + " with flag: " + flag + " interrupted in lockInterruptibly().");
        }
    }


}

class DeadLockChecker {
    private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();

    final static Runnable deadlockCheckRunnable = new Runnable() {
        @Override
        public void run() {
            long[] deadlockedThreads = mbean.findDeadlockedThreads();
            if (deadlockedThreads != null) {
                ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreads);
                for (Thread thread : Thread.getAllStackTraces().keySet()) {
                    for (int i = 0; i < threadInfos.length; i++) {
                        if (thread.getId() == threadInfos[i].getThreadId()) {
                            thread.interrupt();
                        }
                    }
                }
            }
        }
    };

    public static void checkAndStop() {
        Thread thread = new Thread(deadlockCheckRunnable);
        thread.start();
    }

}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class Main implements Runnable{
    static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        System.out.println("Hello world!");

        Main runnable = new Main();
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        try {
            if(lock.tryLock(5, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName() + " tryLock() success");
                Thread.sleep(6000);
            } else {
                System.out.println(Thread.currentThread().getName() + " tryLock() timeout");
                //比如释放其他占用的资源
            }
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " interrupted by lock.tryLock() or Thread.sleep()");
        }
        finally {
            if(lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main implements Runnable {
    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Hello world!");

        Runnable runnable = new Main();
        Thread thread1 = new Thread(runnable);
        thread1.start();

        Thread.sleep(2000);

        lock.lock();
        System.out.println(Thread.currentThread().getName() + " before condition.signalAll()");
        condition.signalAll();
        System.out.println(Thread.currentThread().getName() + " after condition.signalAll()");
        lock.unlock();
    }

    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " before condition.await()");
            condition.await();
        } catch (InterruptedException e) {
            //throw new RuntimeException(e);
            System.out.println(Thread.currentThread().getName() + " interrupted in condition.await()");
        }
        System.out.println(Thread.currentThread().getName() + " finished await");
        lock.unlock();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;

public class Main implements Runnable {
    static Semaphore semaphore = new Semaphore(5);
    public static void main(String[] args) {
        System.out.println("Hello world!");

        Runnable runnable = new Main();

        ExecutorService executor = Executors.newFixedThreadPool(20);
        for(int i = 0; i < 20 ; i++ ) {
            executor.submit(runnable);
        }

    }

    @Override
    public void run() {
        try {
//            semaphore.acquire();
            semaphore.acquire(2);
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " finished a job");
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " interrupted in semaphore.acquire() or Thread.sleep()");
        }
        finally {
//            semaphore.release();
            semaphore.release(2);
        }
    }
}

static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
static Lock readLock = readWriteLock.readLock();
static Lock writeLock = readWriteLock.writeLock();

//...
readLock.lock();
//...
readLock.unlock();
//...


//...
writeLock.lock();
//...
writeLock.unlock();
//...

static final CountDownLatch countDownLatch = new CountDownLatch(3);


//...
//thread1
countDownLatch.await();
//...


//...
//thread2
countDownLatch.countDown();
//...

//...
//thread3
countDownLatch.countDown();
//...

//...
//thread4
countDownLatch.countDown();
//...

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main implements Runnable{
    static CountDownLatch countDownLatch = new CountDownLatch(10);
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Hello world!");

        Runnable runnable = new Main();

        ExecutorService exec = Executors.newFixedThreadPool(10);

        for(int i = 0 ; i < 10; i ++) {
            exec.submit(runnable);
        }

        countDownLatch.await();
        System.out.println("CountDownLatch finished. All work finished");

        exec.shutdown();
    }

    @Override
    public void run() {
        try {
            Thread.sleep(new Random().nextInt(10) * 1000);
            System.out.println(Thread.currentThread().getName() + " finished the work");
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

public CyclicBarrier(int parties, Runnable barrierAction);  //barrierAction是当计数器一次完成计数时，系统会执行的动作 

await();

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello world!");

        BarrierAction barrierAction = new BarrierAction();
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10, barrierAction);

        Thread[] threads = new Thread[10];
        for(int i = 0; i < 10; i++) {
            threads[i] = new Thread(new Solider("solider" + i, cyclicBarrier));
            threads[i].start();
//            if(i == 5) {
//                threads[0].interrupt();
//            }
        }


    }
    static class BarrierAction implements Runnable {
        int step = 0;
        @Override
        public void run() {
            if(step == 0) {
                System.out.println("士兵报到/集合完毕");
            }else {
                System.out.println("士兵们任务完成");
            }
            step++;
        }
    }

    static class Solider implements Runnable {
        String soliderName;

        CyclicBarrier cyclicBarrier;

        public Solider(String name, CyclicBarrier cyclicBarrier) {
            this.soliderName = name;
            this.cyclicBarrier = cyclicBarrier;
        }
        @Override
        public void run() {
            //如果这里出错了，如何保证CyclicBarrier
            try {
                doArrive();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            try {
                System.out.println(soliderName + " 报到");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                System.out.println(soliderName + " 报到时被中断");
            } catch (BrokenBarrierException e) {
                System.out.println(soliderName + " 报到被取消，因为其他solider报到出现了问题");
            }

            //如果这里出错了，如何保证CyclicBarrier
            try {
                doSomeWork();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            try {
                System.out.println(soliderName + " 完成任务");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                System.out.println(soliderName + " 进行任务时被中断");
            } catch (BrokenBarrierException e) {
                System.out.println(soliderName + " 任务被取消，因为其他solider出现了问题");
            }

        }

        void doArrive() throws InterruptedException {
            Thread.sleep(new Random().nextInt(10) * 1000);
        }

        void doSomeWork() throws InterruptedException {
            Thread.sleep(new Random().nextInt(10) * 1000);
        }
    }
}

LockSupport.park();
LockSupport.unpark(thread1);

import java.util.concurrent.locks.LockSupport;

public class Main {
    static final Object u = new Object();
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Hello world!");

        Thread t1 = new TmpThread();
        Thread t2 = new TmpThread();

        t1.start();
        Thread.sleep(1000);
        t2.start();
        LockSupport.unpark(t1);
        LockSupport.unpark(t2); //注意这里unpark实际可能发生在对应的park之前

        t1.join();
        t2.join();
    }

    static class TmpThread extends Thread {

        @Override
        public void run() {
            synchronized (u) {
                LockSupport.park();
            }
        }
    }
}

public Map map = Collections.synchronizedMap(new HashMap());

    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters, the
     * {@linkplain Executors#defaultThreadFactory default thread factory}
     * and the {@linkplain ThreadPoolExecutor.AbortPolicy
     * default rejected execution handler}.
     *
     * <p>It may be more convenient to use one of the {@link Executors}
     * factory methods instead of this general purpose constructor.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);

    /**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to {@code execute} will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");

        MyTask task = new MyTask();
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 1000; i++) {
            executor.submit(task);
//            executor.execute();
        }

        executor.shutdown();
    }

    static class MyTask implements Runnable {
        @Override
        public void run() {
            System.out.println("当前时间：" + System.currentTimeMillis() + "\t当前线程："+ Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        MyTask task = new MyTask();
        //每隔2s执行一次,但是每次执行都会花费1s。所以实际上这里运行起来是3秒一次。
        scheduledExecutorService.scheduleWithFixedDelay(task, 0, 2, TimeUnit.SECONDS);
    }

    static class MyTask implements Runnable {
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis());
            //每次执行都会花费1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        MyTask task = new MyTask();
        //匿名子类实现，覆写了三个方法
        ExecutorService exec = new ThreadPoolExecutor(2, 2, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>()) {
            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println("beforeExecute: 当前线程是：" + Thread.currentThread().getName() + "\t准备用来执行任务的线程是：" + t.getName() + "\t将要执行的任务是：" + r.toString());
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t)  {
                System.out.println("afterExecute: 当前线程是：" + Thread.currentThread().getName() + "\t执行完的任务是：" + r.toString() + "\t可能有异常抛出：" + (t == null ? "" : t.toString()));
            }

            @Override
            protected void terminated() {
                System.out.println("terminated：线程池终结");
            }
        };
        for(int i = 0; i < 10; i++ )
            exec.submit(task);

        exec.shutdown();
    }

    static class MyTask implements Runnable {
        @Override
        public void run() {
            System.out.println("当前线程是：" + Thread.currentThread().getName() + "\t当前时间是：" + System.currentTimeMillis() + "\t正在执行的任务是：" + this.toString());
        }
    }
}

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");


        MyTask task = new MyTask();

        ExecutorService exec = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.SECONDS,
//                new SynchronousQueue<>(),//同步队列，队列长度为0。如果线程都繁忙，没有工作线程从队列中取任务时; （非阻塞方式提交）新提交的任务会失败，触发拒绝策略
                new LinkedBlockingQueue<>(20),
                Executors.defaultThreadFactory(),
                new MyDiscardExecutionHandler());

        for(int i = 0; i < 1000; i++) {
            exec.submit(task);
        }

        exec.shutdown();
    }

    static class MyTask implements Runnable {
        @Override
        public void run() {
            System.out.println("任务正在执行。执行线程：" + Thread.currentThread().getName());
            //假设任务执行消耗100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    static class MyDiscardExecutionHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println("Runnable : " + r + " is discard.");
        }
    }
}

public interface ThreadFactory {
    Thread newThread(Runnable r);
}


public class Executors {
    //...
    public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }

    //...
    //这是Executors类的内部类
    private 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() {
            @SuppressWarnings("removal")
            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;
        }
    }
    //...
}

package java.util.concurrent;

/**
 * An object that executes submitted {@link Runnable} tasks. This
 * interface provides a way of decoupling task submission from the
 * mechanics of how each task will be run, including details of thread
 * use, scheduling, etc.  An {@code Executor} is normally used
 * instead of explicitly creating threads. For example, rather than
 * invoking {@code new Thread(new RunnableTask()).start()} for each
 * of a set of tasks, you might use:
 *
 * <pre> {@code
 * Executor executor = anExecutor();
 * executor.execute(new RunnableTask1());
 * executor.execute(new RunnableTask2());
 * ...}</pre>
 *
 * However, the {@code Executor} interface does not strictly require
 * that execution be asynchronous. 
 * ...
 */
public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package java.util.concurrent;

import java.util.Collection;
import java.util.List;

/**
 * An {@link Executor} that provides methods to manage termination and
 * methods that can produce a {@link Future} for tracking progress of
 * one or more asynchronous tasks.
 *
 * <p>An {@code ExecutorService} can be shut down, which will cause
 * it to reject new tasks.  Two different methods are provided for
 * shutting down an {@code ExecutorService}. The {@link #shutdown}
 * method will allow previously submitted tasks to execute before
 * terminating, while the {@link #shutdownNow} method prevents waiting
 * tasks from starting and attempts to stop currently executing tasks.
 * Upon termination, an executor has no tasks actively executing, no
 * tasks awaiting execution, and no new tasks can be submitted.  An
 * unused {@code ExecutorService} should be shut down to allow
 * reclamation of its resources.
 *
 * <p>Method {@code submit} extends base method {@link
 * Executor#execute(Runnable)} by creating and returning a {@link Future}
 * that can be used to cancel execution and/or wait for completion.
 * Methods {@code invokeAny} and {@code invokeAll} perform the most
 * commonly useful forms of bulk execution, executing a collection of
 * tasks and then waiting for at least one, or all, to
 * complete. (Class {@link ExecutorCompletionService} can be used to
 * write customized variants of these methods.)
 *
 * <p>The {@link Executors} class provides factory methods for the
 * executor services provided in this package.
 *
 * <h2>Usage Examples</h2>
 *
 * Here is a sketch of a network service in which threads in a thread
 * pool service incoming requests. It uses the preconfigured {@link
 * Executors#newFixedThreadPool} factory method:
 *
 * <pre> {@code
 * class NetworkService implements Runnable {
 *   private final ServerSocket serverSocket;
 *   private final ExecutorService pool;
 *
 *   public NetworkService(int port, int poolSize)
 *       throws IOException {
 *     serverSocket = new ServerSocket(port);
 *     pool = Executors.newFixedThreadPool(poolSize);
 *   }
 *
 *   public void run() { // run the service
 *     try {
 *       for (;;) {
 *         pool.execute(new Handler(serverSocket.accept()));
 *       }
 *     } catch (IOException ex) {
 *       pool.shutdown();
 *     }
 *   }
 * }
 *
 * class Handler implements Runnable {
 *   private final Socket socket;
 *   Handler(Socket socket) { this.socket = socket; }
 *   public void run() {
 *     // read and service request on socket
 *   }
 * }}</pre>
 *
 * The following method shuts down an {@code ExecutorService} in two phases,
 * first by calling {@code shutdown} to reject incoming tasks, and then
 * calling {@code shutdownNow}, if necessary, to cancel any lingering tasks:
 *
 * <pre> {@code
 * void shutdownAndAwaitTermination(ExecutorService pool) {
 *   pool.shutdown(); // Disable new tasks from being submitted
 *   try {
 *     // Wait a while for existing tasks to terminate
 *     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
 *       pool.shutdownNow(); // Cancel currently executing tasks
 *       // Wait a while for tasks to respond to being cancelled
 *       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
 *           System.err.println("Pool did not terminate");
 *     }
 *   } catch (InterruptedException ex) {
 *     // (Re-)Cancel if current thread also interrupted
 *     pool.shutdownNow();
 *     // Preserve interrupt status
 *     Thread.currentThread().interrupt();
 *   }
 * }}</pre>
 *
 * <p>Memory consistency effects: Actions in a thread prior to the
 * submission of a {@code Runnable} or {@code Callable} task to an
 * {@code ExecutorService}
 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
 * any actions taken by that task, which in turn <i>happen-before</i> the
 * result is retrieved via {@code Future.get()}.
 *
 * @since 1.5
 * @author Doug Lea
 */
public interface ExecutorService extends Executor {

    /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted.
     * Invocation has no additional effect if already shut down.
     *
     * <p>This method does not wait for previously submitted tasks to
     * complete execution.  Use {@link #awaitTermination awaitTermination}
     * to do that.
     *
     * @throws SecurityException if a security manager exists and
     *         shutting down this ExecutorService may manipulate
     *         threads that the caller is not permitted to modify
     *         because it does not hold {@link
     *         java.lang.RuntimePermission}{@code ("modifyThread")},
     *         or the security manager's {@code checkAccess} method
     *         denies access.
     */
    void shutdown();

    /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks
     * that were awaiting execution.
     *
     * <p>This method does not wait for actively executing tasks to
     * terminate.  Use {@link #awaitTermination awaitTermination} to
     * do that.
     *
     * <p>There are no guarantees beyond best-effort attempts to stop
     * processing actively executing tasks.  For example, typical
     * implementations will cancel via {@link Thread#interrupt}, so any
     * task that fails to respond to interrupts may never terminate.
     *
     * @return list of tasks that never commenced execution
     * @throws SecurityException if a security manager exists and
     *         shutting down this ExecutorService may manipulate
     *         threads that the caller is not permitted to modify
     *         because it does not hold {@link
     *         java.lang.RuntimePermission}{@code ("modifyThread")},
     *         or the security manager's {@code checkAccess} method
     *         denies access.
     */
    List<Runnable> shutdownNow();

    /**
     * Returns {@code true} if this executor has been shut down.
     *
     * @return {@code true} if this executor has been shut down
     */
    boolean isShutdown();

    /**
     * Returns {@code true} if all tasks have completed following shut down.
     * Note that {@code isTerminated} is never {@code true} unless
     * either {@code shutdown} or {@code shutdownNow} was called first.
     *
     * @return {@code true} if all tasks have completed following shut down
     */
    boolean isTerminated();

    /**
     * Blocks until all tasks have completed execution after a shutdown
     * request, or the timeout occurs, or the current thread is
     * interrupted, whichever happens first.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return {@code true} if this executor terminated and
     *         {@code false} if the timeout elapsed before termination
     * @throws InterruptedException if interrupted while waiting
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * Submits a value-returning task for execution and returns a
     * Future representing the pending results of the task. The
     * Future's {@code get} method will return the task's result upon
     * successful completion.
     *
     * <p>
     * If you would like to immediately block waiting
     * for a task, you can use constructions of the form
     * {@code result = exec.submit(aCallable).get();}
     *
     * <p>Note: The {@link Executors} class includes a set of methods
     * that can convert some other common closure-like objects,
     * for example, {@link java.security.PrivilegedAction} to
     * {@link Callable} form so they can be submitted.
     *
     * @param task the task to submit
     * @param <T> the type of the task's result
     * @return a Future representing pending completion of the task
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     * Submits a Runnable task for execution and returns a Future
     * representing that task. The Future's {@code get} method will
     * return the given result upon successful completion.
     *
     * @param task the task to submit
     * @param result the result to return
     * @param <T> the type of the result
     * @return a Future representing pending completion of the task
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * Submits a Runnable task for execution and returns a Future
     * representing that task. The Future's {@code get} method will
     * return {@code null} upon <em>successful</em> completion.
     *
     * @param task the task to submit
     * @return a Future representing pending completion of the task
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    Future<?> submit(Runnable task);

    /**
     * Executes the given tasks, returning a list of Futures holding
     * their status and results when all complete.
     * {@link Future#isDone} is {@code true} for each
     * element of the returned list.
     * Note that a <em>completed</em> task could have
     * terminated either normally or by throwing an exception.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     *
     * @param tasks the collection of tasks
     * @param <T> the type of the values returned from the tasks
     * @return a list of Futures representing the tasks, in the same
     *         sequential order as produced by the iterator for the
     *         given task list, each of which has completed
     * @throws InterruptedException if interrupted while waiting, in
     *         which case unfinished tasks are cancelled
     * @throws NullPointerException if tasks or any of its elements are {@code null}
     * @throws RejectedExecutionException if any task cannot be
     *         scheduled for execution
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    /**
     * Executes the given tasks, returning a list of Futures holding
     * their status and results
     * when all complete or the timeout expires, whichever happens first.
     * {@link Future#isDone} is {@code true} for each
     * element of the returned list.
     * Upon return, tasks that have not completed are cancelled.
     * Note that a <em>completed</em> task could have
     * terminated either normally or by throwing an exception.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     *
     * @param tasks the collection of tasks
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @param <T> the type of the values returned from the tasks
     * @return a list of Futures representing the tasks, in the same
     *         sequential order as produced by the iterator for the
     *         given task list. If the operation did not time out,
     *         each task will have completed. If it did time out, some
     *         of these tasks will not have completed.
     * @throws InterruptedException if interrupted while waiting, in
     *         which case unfinished tasks are cancelled
     * @throws NullPointerException if tasks, any of its elements, or
     *         unit are {@code null}
     * @throws RejectedExecutionException if any task cannot be scheduled
     *         for execution
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * Executes the given tasks, returning the result
     * of one that has completed successfully (i.e., without throwing
     * an exception), if any do. Upon normal or exceptional return,
     * tasks that have not completed are cancelled.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     *
     * @param tasks the collection of tasks
     * @param <T> the type of the values returned from the tasks
     * @return the result returned by one of the tasks
     * @throws InterruptedException if interrupted while waiting
     * @throws NullPointerException if tasks or any element task
     *         subject to execution is {@code null}
     * @throws IllegalArgumentException if tasks is empty
     * @throws ExecutionException if no task successfully completes
     * @throws RejectedExecutionException if tasks cannot be scheduled
     *         for execution
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    /**
     * Executes the given tasks, returning the result
     * of one that has completed successfully (i.e., without throwing
     * an exception), if any do before the given timeout elapses.
     * Upon normal or exceptional return, tasks that have not
     * completed are cancelled.
     * The results of this method are undefined if the given
     * collection is modified while this operation is in progress.
     *
     * @param tasks the collection of tasks
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @param <T> the type of the values returned from the tasks
     * @return the result returned by one of the tasks
     * @throws InterruptedException if interrupted while waiting
     * @throws NullPointerException if tasks, or unit, or any element
     *         task subject to execution is {@code null}
     * @throws TimeoutException if the given timeout elapses before
     *         any task successfully completes
     * @throws ExecutionException if no task successfully completes
     * @throws RejectedExecutionException if tasks cannot be scheduled
     *         for execution
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class Main2 {

    static class MyTask extends RecursiveTask<Long> {
        final int THREADHOLD = 100;
        long start;
        long end;

        public MyTask(long start, long end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute() {
            long count = 0;
            if (end - start < THREADHOLD) {
                for (long i = start; i <= end; i++) {
                    count += i;
                    //模拟其他工作，每次用时10ms
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                return count;
            }

            //分成多个小任务
//            long step = (end - start) / THREADHOLD;
            long step = THREADHOLD;
            List<MyTask> subTasks = new ArrayList<>();
            for (long i = start; i <= end; i+=step) {
                long s = i;
                long e = Math.min(i + step - 1, end);
                MyTask t = new MyTask(s, e);
                subTasks.add(t);
                t.fork();

            }
            for (MyTask t : subTasks)
                count += t.join();
            return count;
        }
    }

    public static void main(String[] args) {
        long sum = 0;
        long startTime = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        MyTask task = new MyTask(1, 1000);
        try {
            sum = forkJoinPool.submit(task).get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }

        long endTime = System.currentTimeMillis();
        System.out.println(sum);
        long duration = endTime - startTime;
        System.out.println("用时" + duration + "ms");
    }
}