java多线程与高并发(五)LockSupport

回顾

首先我们回顾一下前面四节所讲的东西

1.线程的基本概念
2.synchronized，底层实现原理，锁升级（无锁-偏向锁-轻量级锁-重量级锁）
3.volatile，线程隔离可见性，禁止指令重排序
4.AtomicXXX
5.各种UC同步框架（ReentrantLock,CountDownLatch,CyclicBarrier,Phaser,ReadWriteLock,Semaphore,Exchange）
6.synchronized 和 各种线程同步框架的ReenrantLock有何不同？
6.1.synchronizec:系统自带，系统自动加锁，自动解锁，不可以出现多个不同的等待队列，默认进行四种锁的升级
6.2.ReentrantLock:需要自动加锁，手动解锁，可以出现多个不同的等待队列，CAS的实现
本章我们补一个LockSupport，然后分析两个面试题，紧接着我会教大家阅读源码的技巧，最后拿AQS作源码分析

2.LockSupport

我们下面以几个小程序案例，对LockSupport进行详细解释，在以前我们要阻塞和唤醒某一个具体的线程有很多的限制，比如

因为wait方法需要释放锁，所以必须在synchronized中使用，否则会抛出异常lllegalMonitorStateException
nofity方法必须在synchronized中使用，并且应该指定对象
synchronized，nofity,wait的对象必须一致，一个synchronized代码块中只能有一个线程用wait和nofity
以上诸多的使用不便，带来了lockSupport的好处
先来看第一个小程序

package com.learn.thread.four;

import com.sun.tools.internal.ws.wsdl.document.soap.SOAPUse;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

public class TestLockSupport {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                // 使用LockSupport进行线程堵塞
                if (i == 5) {
                    LockSupport.park();
                }
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }

        });
        thread.start();
    }
}

上述代码看起来是比较灵活的，可以手动控制是否上锁，通过LockSupprt.park加锁，有了加锁机制，LockSupport也提供了令牌解锁机制unpark

package com.learn.thread.four;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

public class TestLockSupport2 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                // 使用LockSupport进行线程堵塞
                if (i == 5) {
                    LockSupport.park();
                }
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }

        });
        thread.start();
        // 唤醒线程t,注意这里是比park先执行的，当前与释放了一个令牌，当park拿到这个令牌后不阻塞直接放行
        LockSupport.unpark(thread);
    }
}

注意，这里是一个park对应着一个unpark

package com.learn.thread.four;

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

public class TestLockSupport3 {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                // 使用LockSupport进行线程堵塞
                if (i == 5) {
                    LockSupport.park();
                }

                // 使用LockSupport进行线程堵塞(前面只会释放一次锁，这里会再次阻塞)
                if (i == 8) {
                    LockSupport.park();
                }
            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }

        });
        thread.start();
        LockSupport.unpark(thread);
    }

}

2.1.由以上三个小程序，我们可以总结出以下几点

LockSupport不需要synchronized就可以实现线程的阻塞和唤醒
LockSupport.unpark可以线程LockSupport.park，并且线程不会阻塞
如果一个线程处于等待状态，连续调用了两次park方法，就会使该线程永远无法唤醒
LockSupport中的park 和unpark的实现原理

其实park（）和unpark()的实现也是由Unsefa类提供的，而Unsefa类是由C和c++语言完成的，其实原理也是可以理解，它主要是通过一个变量作为标志，变量在0-1之间来回切换，当这个变量大于0的时候线程就获得了“令牌”(unpark的操作)，相反park的操作就是将这个变量变成0，用于识别令牌。

2.2.淘宝面试题1

实现一个容器，提供两个方法add和size 写两个线程
线程1：添加十个元素到容器中
线程2：实时监控元素个数，当个数到5个时，线程2给出提示并结束

小程序1
我们先来分析一下小程序1的执行流程：
通过内部的List来new 一个ArraryList，在自定义的add方法直接调用list的add方法，在自定义的size方法调用list的size方法。然后小程序初始化这个List,启动线程t1来做一个循环，每次循环都添加一个对象，加一个打印，然后间隔一秒，在t2线程写一个while循环，实时监控集合中对象的变换，如果数量达到5就结束t2的线程。

package com.learn.thread.four.list;

import java.util.ArrayList;
import java.util.List;

public class TestListAdd1 {
    List