import java.util.concurrent.*;

public class SleepTry {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
      	//这个StringBuilder是创建在进程堆上的，所以他是会被共享的，创建线程的时候会拷贝一个引用副本
      	//所以任何线程都可以操作并修改他，修改的并不是线程自己创建的，而是进程所创建的
        StringBuilder sb =new StringBuilder();
        BlockingQueue<Runnable> bq =new LinkedBlockingQueue<>();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,10,1000L, TimeUnit.SECONDS,bq);
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                synchronized (sb){
                    sb.append("I am Thread2\n");
                }
                countDownLatch.countDown();
            }
        };
        Future<?> feature2 =  threadPoolExecutor.submit(task2);
        feature2.get();
        System.out.println(sb.toString());
        threadPoolExecutor.shutdownNow();
    }
}

public class FutureTask<V> implements RunnableFuture<V> {
    /*
     * Revision notes: This differs from previous versions of this
     * class that relied on AbstractQueuedSynchronizer, mainly to
     * avoid surprising users about retaining interrupt status during
     * cancellation races. Sync control in the current design relies
     * on a "state" field updated via CAS to track completion, along
     * with a simple Treiber stack to hold waiting threads.
     */

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

class Thread3 extends Thread{
    @Override
    public void run(){
        System.out.println("Hello zhima.");
    }
}
Thread3 thread3 = new Thread3();
thread3.start();

class Thread4 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        Random random = new Random();
        return random.nextInt(114514,114515);
    }
}
FutureTask<Integer> ft = new FutureTask<>(new Thread4());
Thread t4 = new Thread(ft);
t4.start();
Integer rand = ft.get();
System.out.println(rand);
//114514

//创建大小固定的线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
//也可以创建一个
ExecutorService executorService1 = Executors.newSingleThreadExecutor();
//也可以直接new一个ThreadPoolExecutor
//要指定的东西就比较多了，包括核心线程数，最大的线程数，非核心空闲线程AliveTime，AliveTime的单位，以及用来存储等待任务的阻塞队列
//如果阻塞队列用ArrayBlockingQueue的话还要指定最大大小
BlockingQueue<Runnable> blockingQueue =new LinkedBlockingQueue<>();
ThreadPoolExecutor executorService2 = new ThreadPoolExecutor(5,10,1000L, TimeUnit.SECONDS,blockingQueue);

import java.util.Random;
import java.util.concurrent.*;

public class SleepTry {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        StringBuilder sb =new StringBuilder();
        BlockingQueue<Runnable> bq =new LinkedBlockingQueue<>();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,10,1000L, TimeUnit.SECONDS,bq);
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                synchronized (sb){
                    sb.append("hello\n");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    sb.append("I am Thread1\n");
                }
                countDownLatch.countDown();
            }
        };
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                synchronized (sb){
                    sb.append("I am Thread2\n");
                }
                countDownLatch.countDown();
            }
        };
        Future<?> feature1 =  threadPoolExecutor.submit(task1);
        Thread.sleep(10);
        Future<?> feature2 =  threadPoolExecutor.submit(task2);
        countDownLatch.await();
        //feature1.get();
        //feature2.get();
        System.out.println(sb.toString());
        threadPoolExecutor.shutdownNow();
    }
}

hello
I am Thread1
I am Thread2

import java.util.Random;
import java.util.concurrent.*;

public class SleepTry {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        StringBuilder sb =new StringBuilder();
        BlockingQueue<Runnable> bq =new LinkedBlockingQueue<>();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,10,1000L, TimeUnit.SECONDS,bq);
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                synchronized (sb){
                    sb.append("hello\n");
                    try {
                        sb.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    sb.append("I am Thread1\n");
                }
                countDownLatch.countDown();
            }
        };
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                synchronized (sb){
                    sb.append("I am Thread2\n");
                    sb.notifyAll();
                }
                countDownLatch.countDown();
            }
        };
        Future<?> feature1 =  threadPoolExecutor.submit(task1);
        Thread.sleep(10);
        Future<?> feature2 =  threadPoolExecutor.submit(task2);
        //feature1.get();
        //feature2.get();
        countDownLatch.await();
        System.out.println(sb.toString());
        threadPoolExecutor.shutdownNow();
    }
}

hello
I am Thread2
I am Thread1

sb.wait(100);

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

ReentrantLock reentrantLock = new ReentrantLock(true);
reentrantLock.lockInterruptibly();
boolean flag = reentrantLock.tryLock(10, TimeUnit.MICROSECONDS);

/**
 * Atomically sets the value to {@code newValue}
 * if the current value {@code == expectedValue},
 * with memory effects as specified by {@link VarHandle#compareAndSet}.
 *
 * @param expectedValue the expected value
 * @param newValue the new value
 * @return {@code true} if successful. False return indicates that
 * the actual value was not equal to the expected value.
 */
public final boolean compareAndSet(int expectedValue, int newValue) {
    return U.compareAndSetInt(this, VALUE, expectedValue, newValue);
}