Lock lock = new ReentrantLock();   //创建Lock对象
Condition condition = lock.newCondition();  //获取Condition对象

//创建资源类
class Ticket{
    private int number = 30;//定义属性：票数
    //操作方法
    public synchronized void sale(){
        //判断：是否还有票
        if(number>0){
            System.out.print("当前"+number+"张--");
            number--;
            System.out.println(Thread.currentThread().getName()+": 卖出1，剩余"+number+"张");
        }
    }
}

public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //创建资源类对象
        //创建3个线程，代表3个售票员
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<30;i++){
                    ticket.sale();
                }
            }
        },"售票员A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<30;i++){
                    ticket.sale();
                }
            }
        },"售票员B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<30;i++){
                    ticket.sale();
                }
            }
        },"售票员C").start();
    }

class LTicket{
    private int number=30;
    //创建可重入锁对象
    private final ReentrantLock lock = new ReentrantLock();
    //编写方法
    public void sale(){
        //上锁
        lock.lock();  //一般将上锁操作写在try外面,且和try直接不能有其他操作
        try{
            //做操作
            if(number>0){
                System.out.print("当前"+number+"张--");
                number--;
                System.out.println(Thread.currentThread().getName()+": 卖出1，剩余"+number+"张");
            }
        }finally {  //将解锁操作放到finally中，保证一定能够解锁
            //解锁
            lock.unlock();
        }
    }
}

public class SaleTicket_L {
    public static void main(String[] args) {
        LTicket lTicket = new LTicket();
        //调用start方法不一定是马上创建线程，需要底层操作系统情况。
        new Thread(()->{for(int i=0;i<30;i++) lTicket.sale();},"售票员A").start();
        new Thread(()->{for(int i=0;i<30;i++) lTicket.sale();},"售票员B").start();
        new Thread(()->{for(int i=0;i<30;i++) lTicket.sale();},"售票员C").start();
    }
}

//一、创建资源类，定义属性和操作方法
//操作方法中判断、操作、通知
class Share{
    //初始值
    private int number = 0;
    //+1的方法
    public synchronized void increat() throws InterruptedException {
        /*
        if只会判断一次，wait在哪里睡就在哪里醒，因此如果使用if，则会导致虚假唤醒问题。
        解决虚假唤醒问题，需要使用while代替if，因为while每次都会判断
         */
        while(number !=0){
            wait(); //如果值不是0，就释放锁,进入阻塞状态，等待被唤醒
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        notifyAll();
    }
    //-1的方法
    public synchronized void decreat() throws InterruptedException {
        while(number !=1){
            wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"::"+number);
        notifyAll();
    }

}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for(int i=1;i<=10;i++){
                try {
                    share.increat();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Thread A").start();
        new Thread(() -> {
            for(int i=1;i<=10;i++){
                try {
                    share.decreat();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Thread B").start();
    }
}

//第一步：创建资源类，定义属性和操作方法
class Share{
    private int number = 0;
    //创建Lock对象
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    //定义方法
    public void incr() throws InterruptedException {
        lock.lock();//上锁
        try {
            while(number!= 0){condition.await();}//判断
            number++;//操作
            System.out.println(Thread.currentThread().getName()+"::"+number);
            condition.signalAll();//通知
        } finally {
            lock.unlock();//解锁
        }
    }

    public void decr() throws InterruptedException {
        lock.lock();
        try{
            while(number!=1){condition.await();}
            number--;
            System.out.println(Thread.currentThread().getName()+"::"+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}
public class ThreadDemo1_L {
    public static void main(String[] args) {
        Share share = new Share();
        //创建A、B两个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    try {
                        share.incr();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"Thread A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    try {
                        share.decr();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"Thread B").start();
    }
}

/*线程通信案例2：
实现线程间的定制化通信：A线程打印5次，B线程打印10次，C线程打印15次，重复以上步骤n次
实现方法为设置标志位flag，1表示A执行，2表示B执行，3表示C执行
 */
class ShareResource{
    private int flag = 1;  // 1-A,2-B,3-C
    private Lock lock = new ReentrantLock(); //声明锁
    //为了实现定制化通信，需要创建3个condition；保证唤醒的是指定的线程
    private Condition c1 =  lock.newCondition();  //相当于钥匙，用于通信
    private Condition c2 =  lock.newCondition();
    private Condition c3 =  lock.newCondition();

    public void print5(int loop) throws InterruptedException {
        lock.lock();
        try{
            while(flag!=1){
                c1.await();
            }
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"::"+i+",当前轮数:"+loop);
            }
            flag = 2; //修改标志位是2
            c2.signal();  //通知B线程；signal表示唤醒当前Condition对象中的等待队列中的一个线程。
        }finally {
            lock.unlock();
        }
    }

    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try{
            while(flag!=2){
                c2.await();
            }
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"::"+i+",当前轮数:"+loop);
            }
            flag = 3; //修改标志位是2
            c3.signal();  //通知C线程；signal表示唤醒当前Condition对象中的等待队列中的一个线程。
        }finally {
            lock.unlock();
        }
    }

    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try{
            while(flag!=3){
                c3.await();
            }
            for(int i=0;i<15;i++){
                System.out.println(Thread.currentThread().getName()+"::"+i+",当前轮数:"+loop);
            }
            flag = 1; //修改标志位是2
            c1.signal();  //通知A线程；signal表示唤醒当前Condition对象中的等待队列中的一个线程。
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo2_L {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    try {
                        shareResource.print5(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    try {
                        shareResource.print10(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    try {
                        shareResource.print15(i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"C").start();
    }
}

public class ThreadDemo4_L {
    public static void main(String[] args) {
        ThreadDemo4_L demo4L = new ThreadDemo4_L();
        demo4L.testHashMap();
    }
    public void testHashMap(){
        Map<String,String> map = new HashMap<>();
        for(int i=1;i<=100;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //向hashmap中写入随机数
                    map.put(UUID.randomUUID().toString().substring(0,8),"t");
                    System.out.println(map);
                }
            },String.valueOf(i)).start();
        }
    }
}

public interface Future<V> {
    //用于停止任务
    boolean cancel(boolean mayInterruptIfRunning);
    
    //如果任务在完成前被取消，则返回true
    boolean isCancelled();
    
    //如果任务完成，返回true，否则返回false
    boolean isDone();
    
    //用户获取任务的结果
    V get() throws InterruptedException, ExecutionException;
    
    //在指定的等待时间内，获取结果，如果超时还没有获取到结果，则抛出超时异常
    V get(long timeout, TimeUnit unit) throws InterruptedException,
    ExecutionException, TimeoutException;
}

//实现Callable接口
class MyThread2 implements Callable {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"--come in callable");
        return 200;
    }
}

public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
        //创建FutureTask对象并传入Callable实现类对象
        FutureTask<Integer> futureTask1 = new FutureTask<>(new MyThread2());
        new Thread(futureTask1,"futureTask1").start();
    }
}

/*
场景：当教室的n个人都离开后，才可以锁门
*/
public class countDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //1.创建CountDownLatch对象并设置初始计数值，假设有6个学生
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for(int i=1;i<=6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+":离开");
                countDownLatch.countDown();  //每次一个线程离开后，计数器减一
            },String.valueOf(i)).start();
        }
        //只要计数器大于0，当前线程就一直等待；直到计数器等于0，当前线程才被唤醒
        countDownLatch.await(); 
        System.out.println(Thread.currentThread().getName()+"可以关灯了");
    }
}

//场景：集齐七颗龙珠召唤神龙
public class CyclicBarrierDemo {
    private static final int NUMBER = 7;
    public static void main(String[] args) {
        //新建循环栅栏对象，设置一个固定值，并指定达到这个固定值以后，需要做的事
        CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, () -> {
            System.out.println("召唤神龙!");
        });

        //集齐七颗龙珠的过程
        for(int i=1;i<=7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"星龙珠已收集到");
                try {
                    //await表示已经到达栅栏，每执行一次，计数加一
                    cyclicBarrier.await();   
                    //如果没有到达指定的7颗，cyclicBarrier会一直处于等待状态
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

//场景：6辆汽车，停到3个车位
public class SemaphoreDemo {
    public static void main(String[] args) {
        //创建semaphore，模拟3个车位，即设置3个许可量，即同时只能有3个线程获取到许可量
        Semaphore semaphore = new Semaphore(3);
        //模拟6辆汽车
        for(int i=1;i<=6;i++){
            new Thread(()->{
                try {
                    //获取许可量，即占用车位
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢占到了车位");
                    //模拟停车时间
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放许可量
                    semaphore.release();
                }
            },i+"号车").start();
        }
    }
}

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     * @return the lock used for writing
     */
    Lock writeLock();
}

//场景：模拟缓存机制
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        //创建线程放数据
        for(int i=1;i<=5;i++){
            final int num = i;
            new Thread(()->{
                myCache.put(num+"",num+"");
            },"线程"+i).start();
        }
        //创建线程取数据
        for(int i=1;i<=5;i++){
            final int num = i;
            new Thread(()->{
                myCache.get(num+"");
            },"线程"+i).start();
        }
    }
}

//使用读写锁，每次读和写之前都上锁，保证了不会出现还没写完就读的情况
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

    //创建读写锁对象
    private ReadWriteLock rwl = new ReentrantReadWriteLock();

    //放数据
    public void put(String key, Object value) {
        rwl.writeLock().lock(); //加上一个写锁
        try {
            System.out.println(Thread.currentThread().getName()+"正在写"+key);
            TimeUnit.MILLISECONDS.sleep(300);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写完了"+key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放写锁
            rwl.writeLock().unlock();
        }
    }
    
    //取数据
    public Object get(String key)  {
        //添加读锁
        rwl.readLock().lock();
        Object o = null;
        try {
            System.out.println(Thread.currentThread().getName()+"正在读"+key);
            TimeUnit.MILLISECONDS.sleep(300);
            o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读完了"+key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            rwl.readLock().unlock();
        }
        return o;
    }
}
/*运行结果
线程1正在写1
线程1写完了1
线程3正在写3
线程3写完了3
线程4正在写4
线程4写完了4
线程5正在写5
线程5写完了5
线程2正在写2
线程2写完了2
线程1正在读1
线程4正在读4
线程3正在读3
线程2正在读2
线程5正在读5
线程2读完了2
线程5读完了5
线程4读完了4
线程3读完了3
线程1读完了1
*/

// 以银行窗口办理业务为例
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //一池5线程，表示5个窗口
        ExecutorService threadPool1 = Executors.newFixedThreadPool(5);  
        try{
            //假设有10个顾客
            for(int i=1;i<=10;i++){
                threadPool1.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在办理业务");
                });
            }
        }finally {
            //关闭线程池
            threadPool1.shutdown();
        }
    }
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

//自定义线程池
public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //自定义线程池,
        //常驻线程数量为2，最大为5，超时时间为0秒，阻塞队列为3，拒绝策略为AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 5, 0L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //使用线程池。模拟10个客户
        try{
            for(int i=1;i<=10;i++){
                threadPoolExecutor.execute(() -> System.out.println(
                    Thread.currentThread().getName()+"正在办理业务"));
            }
        }finally {
            threadPoolExecutor.shutdown();
        }
    }
}