多线程核心知识

yield()让出线程时间片，增大线程切换的几率。由于它是native修饰的，所以是通过其他语言直接操作机器实现的。

public static native void yield();

sleep(long millis)会让线程阻塞住millis秒，在这个时间段内不再参与到CPU竞争。sleep()是通过millis参数来设置一个定时器实现的，时间一结束，若没有其他线程正在执行，则会同其他线程一起抢占cpu资源。

public static native void sleep(long millis) throws InterruptedException;

我们现在有两个线程的话，在第二个线程里面调用第一个线程的join方法，程序会立即切换到第一个线程去执行。点进去thread.join()源码发现，join主要是下面几行代码实现的。
    public final void join() throws InterruptedException {
        // 最多等待millis毫秒，此线程才能死；millis=0意味着永远等待。
        join(0);
    }
    
    // 可以看到调用join(long millis)方法，实际还是通过synchronized实现的。
    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {//如果线程还没执行完
                wait(0);//释放对象锁，程序停止执行。
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
可以看到join的底层还是对方法加锁，然后通过wait()使自己阻塞，从而切换到其他线程执行；join()方法的java文档中写到：a thread terminates the  this.notifyAll method is invoked.也就是说，其他线程run()方法运行完了以后，会调用this.notifyAll，释放锁。这样线程获得锁以后就可以继续往下执行了。

wait()会让线程休眠，释放锁。
(1)为什么 wait/notify/notifyAll一定要放在同步代码块里，我们可以看下面这个案例。

boolean flag = false;

// A线程代码
while(!flag){
    wait();
}

// B线程代码
if(!flag){
    condition = true;
    // nofity随机唤醒一个等待的线程;notifyAll唤醒等待该锁的所有线程
    notify();
}

1. 如果线程A刚执行完while(!flag)，准备执行wait(),此时线程A的时间片已经耗尽
2. B线程执行完 condition = true; notify();的操作，由于A并没有wait，所以B的notify不会起任何效果
3. 此时A又获得了时间片，继续执行wait()，此时由于没有notify()唤醒她，那么她会一直沉睡下去。
所以相当于：锁对象里面维护了一个队列，线程A执行lock的wait方法，把线程A保存到list中，线程B中执行lock的notify方法，从等待队列中取出线程A继续执行。

(2)为什么 wait要放在while中判断而不是if中

如果采用if判断，当线程从wait中唤醒时，判断条件已经不满足处理业务逻辑的条件了，从而出现错误的结果。所以我们业务需要像下面一样在判断一次。而循环则是对上述写法的简化

synchronized (monitor) {
    //  判断条件谓词是否得到满足
    if(!locked) {
        //  等待唤醒
        monitor.wait();
        if(locked) {
            //  处理其他的业务逻辑
        } else {
            //  跳转到monitor.wait(); 
        }
    }
}

/**
 * 自定义线程池
 */
public class ExecutorDemo {
    public static void main(String[] args) {
        /**
         * 上面4种线程池的创建其实都是对于ThreadPoolExecutor的封装，点进去看发现就是：
         * new ThreadPoolExecutor(int corePoolSize,
         *                           int maximumPoolSize,
         *                        long keepAliveTime,
         *                        TimeUnit unit,
         *                        new LinkedBlockingQueue<Runnable>())
         */
        /**
         * @param corePoolSize 核心线程数(空闲也不会被回收)
         * @param maximumPoolSize 最大线程数
         * @param keepAliveTime 线程空闲时的超时时间
         * @param TimeUnit 超时时间单位
         * @param BlockingQueue<Runnable> 阻塞队列，线程排队时就装在这个队列里面
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,2,0L,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(3));
        /**
         * 上面已经创建好线程池了，核心线程为1，也就是初始线程数为1；最大线程2；队列最多容纳3个线程等待。下面我们有6个任务要执行
         * (1) 第一个任务开始，直接就交给了核心线程去执行
         * (2) 后面的线程进来，由于没有线程了就会放到队列里面去等待。如果之前的线程空闲了就会继续复用；否则放入队列等待新的线程创建
         * (3) 假使线程都在使用中，因为最大线程数为2，那么最多同时运行2个线程，由于队列也只能排队3个线程，那么这个线程池最多就只能容纳5个线程
         * (4) 如果线程池已经被占满，此时还有第6个任务要进来，那么线程池就会溢出报错。
         */
        for (int i = 1; i <= 6; i++) {
            final int temp = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "任务" + temp);
                }
            });
        }
        /**
         * 控制台输出
         * pool-1-thread-1任务1
         * pool-1-thread-1任务2
         * pool-1-thread-1任务3
         * pool-1-thread-1任务4
         * pool-1-thread-2任务5
         * java.util.concurrent.RejectedExecutionException: Task com.Thread.A_newThread.pool.ExecutorDemo$1@6d6f6e28 rejected from java.util.concurrent.ThreadPoolExecutor@135fbaa4[Running, pool size = 2, active threads = 2, queued tasks = 3, completed tasks = 0]
         *     at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
         *     at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
         *     at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
         *     at com.Thread.A_newThread.pool.ExecutorDemo.main(ExecutorDemo.java:35)
         */
    }
}