多线程面试题（一）

题目要求：
实现一个容器，提供两个方法add、size，写两个线程：
线程1，添加10个元素到容器中；
线程2，实时监控元素个数，当个数到5个时，线程2给出提示并结束。

以下提供几种实现方式，仅供参考，不限于这几种。

方式一：使用synchronized配合wait()/notify（）

package com.yang.bootmongo.controller.interview;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Author: Gy
 * @Description:  方式一：使用synchronized锁配合wait()/notify()方法实现
 *                关键点：1、wait()方法使当前线程阻塞并释放掉锁资源，代码执行到该方法调用处停下，欲继续执行，需再次获得锁
 *                      2、notify()方法与wait()方法相对，唤醒阻塞线程继续执行，但仅仅是唤醒，不释放锁，被唤醒的线程如果未得到锁，依旧阻塞
 * @Date Created in 2022-08-03 15:02
 * @Modified By:
 */
public class TestSync {
    //volatile 感觉不加也行，加了更加严谨一点
    /*volatile*/ List list = new ArrayList();
    public void add(Object o){
        list.add(o);
    }
    public int getSize(){
        return list.size();
    }

    public static void main(String[] args) {
        TestSync testSync = new TestSync();
        new Thread(()->{
            synchronized (testSync){
                try {
                    System.out.println("t1 start...");
                    //t1进入阻塞，停在当前位置，再次获得锁之后，才能在该位置继续执行
                    testSync.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1 end...");
                //唤醒t2,让t2继续执行
                testSync.notify();
            }
        },"t1").start();
        //主线程睡1秒，保证t1先启动
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            synchronized (testSync){
                System.out.println("t2 start...");
                for (int i = 0; i < 10; i++) {
                   testSync.add(new Object());
                    System.out.println("add "+i);
                   if (testSync.getSize() == 5){
                       try {
                           //通知t1运行
                           testSync.notify();
                           //释放锁，供t1使用，然后t2阻塞
                           testSync.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
                }
                System.out.println("t2 end...");
            }
        }).start();
    }
}

方式二：使用LockSupport提供的静态方法park()/unpark()

package com.yang.bootmongo.controller.interview;

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

/**
 * @Author: Gy
 * @Description: 使用LockSupport提供的静态方法，park()/unpark()
 * @Date 
 * @Modified By:
 */
public class TestLockSupport {
    List list = new ArrayList();

    public void add(Object o) {
        list.add(o);
    }

    public int getSize() {
        return list.size();
    }

    static Thread t1 = null, t2 = null;

    public static void main(String[] args) throws InterruptedException {

        TestLockSupport testLockSupport = new TestLockSupport();

        t1 = new Thread(() -> {
            System.out.println("t1 start...");
            LockSupport.park();
            System.out.println("t1 end...");
            LockSupport.unpark(t2);
        });

        t2 = new Thread(() -> {
            System.out.println("t2 start...");
            for (int i = 0; i < 10; i++) {
                testLockSupport.add(new Object());
                System.out.println("add " + i);
                if (testLockSupport.getSize() == 5) {
                    //注意以下两行语句的顺序
                    LockSupport.unpark(t1);
                    LockSupport.park();
                }
            }
            System.out.println("t2 end...");
        });

        t1.start();

        TimeUnit.SECONDS.sleep(1);

        t2.start();
    }
}

方式三：使用CountDownLatch配合await()/countDown()

package com.yang.bootmongo.controller.interview;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * @Author: Gy
 * @Description: 使用两组CountDownLatch
 * @Date
 * @Modified By:
 */
public class TestCountDownLatch {
    List list = new ArrayList();

    public void add(Object o) {
        list.add(o);
    }

    public int getSize() {
        return list.size();
    }

    public static void main(String[] args) throws InterruptedException {

        TestCountDownLatch countDownLatch = new TestCountDownLatch();
        CountDownLatch countDownLatch1 = new CountDownLatch(1);
        CountDownLatch countDownLatch2 = new CountDownLatch(1);
        Thread t1 = new Thread(() -> {
            System.out.println("t1 start...");
            try {
                countDownLatch1.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1 end...");
            countDownLatch2.countDown();
        });

        Thread t2 = new Thread(() -> {
            System.out.println("t2 start...");
            for (int i = 0; i < 10; i++) {
                countDownLatch.add(new Object());
                System.out.println("add " + i);
                if (countDownLatch.getSize() == 5) {
                    try {
                        countDownLatch1.countDown();
                        countDownLatch2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("t2 end...");
        });

        t1.start();

        TimeUnit.SECONDS.sleep(1);

        t2.start();
    }
}

以上提供的三种方式关键点是先启动监控线程t1，执行结果统一为：

不得不说，我真的好良心,给自己一个赞。