多线程与高并发（11）——经典面试题之实现一个容器，提供两个方法，add，size。

已于 2022-08-12 09:17:06 修改
阅读量306 收藏 2
点赞数
分类专栏： 多线程 java 文章标签： java 面试
于 2022-08-09 17:57:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liwangcuihua/article/details/126248815
版权

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

1、普通方法

public class Test_Container {

    List list = new ArrayList<>();
    private void add(Object o) {
        list.add(o);
    }
    private Integer size() {
        return list.size();
    }
    
   public static void main(String[] args) {
        Test_Container container = new Test_Container();

        new Thread(() -> {
            System.out.println("T1 开始");
            for (int i = 1; i <= 10; i++) {
                container.add(new Object());
                System.out.println("add + " + i);

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
            System.out.println("T1 结束");
        }, "T1").start();

        new Thread(() -> {
            System.out.println("T2 开始");
            while(true){
                if(container.size()==5){
                    break;
                }
            }
            System.out.println("T2 结束");
        }, "T2").start();
    }
}

赶早不如赶巧，一上来我就运行出了死循环的结果…
在这里插入图片描述
这是为什么呢？很简单，因为线程2开始的时候，线程1都执行到7了！
还有一种情况，如下图：
在这里插入图片描述
T2结束的时候，T1都执行到6了。
我们加volatile关键字尝试一下。

2、volatile关键字

public class Test_ContainerWithVolatile {

    volatile List list = new ArrayList<>();
    private void add(Object o) {
        list.add(o);
    }
    private Integer size() {
        return list.size();
    }

    public static void main(String[] args) {
        Test_ContainerWithVolatile container = new Test_ContainerWithVolatile();

        new Thread(() -> {
            System.out.println("T1 开始");
            for (int i = 1; i <= 10; i++) {
                container.add(new Object());
                System.out.println("add + " + i);
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
            System.out.println("T1 结束");
        }, "T1").start();

        new Thread(() -> {
            System.out.println("T2 开始");
            while(true){
                if(container.size()==5){
                    break;
                }
            }
            System.out.println("T2 结束");
        }, "T2").start();
    }
}

看上去没有死循环的问题：
在这里插入图片描述
但是，是因为我加了sleep的原因，如果不加sleep，还是不行。
所以，volatile关键字是不可以的，为什么不可以呢，volatile关键字禁止指令重排序，保证线程可见性，但是又保证不了原子性，更保证不了线程等待不运行。你想读到size=5的时候，他可能都变成6了。
我们用wait和notify实现尝试一下。

3、wait和notify实现

wait()方法的作用是释放锁，加入到等待队列。调用notify或者notifyAll方法不释放锁，只是让他参与锁的竞争中去。

public class Test_ContainerWithWait {
    //及时可见
    volatile List list = new ArrayList<>();

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

    private Integer size() {
        return list.size();
    }

    public static void main(String[] args) {
        Test_ContainerWithWait container = new Test_ContainerWithWait();
        //用来上锁的对象
        Object o = new Object();
        new Thread(() -> {
            System.out.println("T2 开始");
            if (container.size() != 5) {
                try {
                    //wait()方法必须在同步关键字修饰的方法中才能调用。
                    synchronized (o) {
                        o.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("T2 结束");
        }, "T2").start();
        //保证线程2先运行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            System.out.println("T1 开始");
            for (int i = 1; i <= 10; i++) {
                container.add(new Object());
                System.out.println("add + " + i);
                if (container.size() == 5) {
                    synchronized (o) {
                        //notify不释放锁
                        o.notify();
                    }
                }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("T1 结束");
        }, "T1").start();

    }
}

上面代码，执行结果如下，执行结果正常，但是，这是有问题的：
在这里插入图片描述
notify不释放锁，只是让对象去争这把锁，其中真正起作用的还是Thread.sleep(1000);这个，T2先去执行了。如果是以下写法：

new Thread(() -> {
            synchronized (o) {
                System.out.println("T1 开始");
                for (int i = 1; i <= 10; i++) {
                    container.add(new Object());
                    System.out.println("add + " + i);
                    if (container.size() == 5) {

                        //notify不释放锁
                        o.notify();
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T1 结束");
            }
        }, "T1").start();

我们把锁加在代码逻辑的最外层，结果如下：
在这里插入图片描述
notify不释放锁，T2在5这个时候还是拿不到锁。怎么解决呢？正确写法如下;

public static void main(String[] args) {
        Test_ContainerWithWait container = new Test_ContainerWithWait();
        //用来上锁的对象
        Object o = new Object();
        new Thread(() -> {
            synchronized (o) {
                System.out.println("T2 开始");
                if (container.size() != 5) {
                    try {
                        //wait()方法必须在同步关键字修饰的方法中才能调用。
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T2 结束");
                //唤醒锁让T1继续执行
                o.notify();
            }
        }, "T2").start();
        //保证线程2先运行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            synchronized (o) {
                System.out.println("T1 开始");
                for (int i = 1; i <= 10; i++) {
                    container.add(new Object());
                    System.out.println("add + " + i);
                    if (container.size() == 5) {
                        //notify不释放锁
                        o.notify();
                        try {
                            //通过wait释放锁
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T1 结束");
            }
        }, "T1").start();

    }

两个地方，一个是在T1线程里通过wait释放锁，一个是在T2线程里notify让T1继续执行。结果如下：
在这里插入图片描述

4、使用CountDownLatch

CountDownLatch字面意思是倒数门栓，也就是倒数计数多少个线程执行完毕了。 其允许 int个线程阻塞在一个地方，直至所有线程的任务都执行完毕。
代码如下：

 public static void main(String[] args) {
        Test_ContainerWithLatch container = new Test_ContainerWithLatch();
        CountDownLatch countDownLatch = new CountDownLatch(1);

        new Thread(() -> {
                System.out.println("T2 开始");
                if (container.size() != 5) {
                    try {
                        //上锁，等待
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T2 结束");
        }, "T2").start();

        new Thread(() -> {
                System.out.println("T1 开始");
                for (int i = 1; i <= 10; i++) {
                    container.add(new Object());
                    System.out.println("add + " + i);
                    if (container.size() == 5) {
                        //开门，执行T2
                        countDownLatch.countDown();
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T1 结束");

        }, "T1").start();

    }

执行结果如下：
在这里插入图片描述
当然如果sleep方法没加，这个也是不能实现的。解决办法就是加两个门栓！代码如下：

 public static void main(String[] args) {
        Test_ContainerWithLatch container = new Test_ContainerWithLatch();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        CountDownLatch countDownLatch2 = new CountDownLatch(1);

        new Thread(() -> {
                System.out.println("T2 开始");
                if (container.size() != 5) {
                    try {
                        //上锁，等待
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T2 结束");
            //叫醒T1
            countDownLatch2.countDown();
        }, "T2").start();

        new Thread(() -> {
                System.out.println("T1 开始");
                for (int i = 1; i <= 10; i++) {
                    container.add(new Object());
                    System.out.println("add + " + i);
                    if (container.size() == 5) {
                        //开门，执行T2
                        countDownLatch.countDown();
                        try {
                            //让t1等t2执行完
                            countDownLatch2.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                  /*  try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                }
                System.out.println("T1 结束");

        }, "T1").start();
       }

5、Semaphore 实现

Semaphore 允许几个线程同时执行，灯亮执行，灯灭不执行。其主要作用是用来限流。这里就用来上锁放行哈哈哈哈哈。

 public static void main(String[] args) {
        Test_ContainerWithSeam container = new Test_ContainerWithSeam();
        Semaphore semaphore1 = new Semaphore(0);
        Semaphore semaphore2 = new Semaphore(0);

        new Thread(() -> {
                System.out.println("T2 开始");
                if (container.size() != 5) {
                    try {
                        //上锁，等待
                        semaphore1.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("T2 结束");
            //叫醒T1
            semaphore2.release();
        }, "T2").start();

        new Thread(() -> {
                System.out.println("T1 开始");
                for (int i = 1; i <= 10; i++) {
                    container.add(new Object());
                    System.out.println("add + " + i);
                    if (container.size() == 5) {
                        //开门，执行T2
                        semaphore1.release();
                        try {
                            //让t1等t2执行完
                            semaphore2.acquire();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("T1 结束");

        }, "T1").start();

    }

6、LockSupport实现

LockSupport主要作用就是阻塞和唤醒线程。
unpark()可以先于park调用，所以不需要担心线程间的执行的先后顺序。
代码如下：

    static Thread t1, t2;
    public static void main(String[] args) {
        Test_ContainerWithSeam container = new Test_ContainerWithSeam();

         t2 = new Thread(() -> {
            System.out.println("T2 开始");
            //可以不用判断
            if (container.size() != 5) {
                //上锁，等待
                LockSupport.park();
            }
            System.out.println("T2 结束");
            //叫醒T1
            LockSupport.unpark(t1);
        }, "T2");
        t2.start();

        Thread t1 = new Thread(() -> {
            System.out.println("T1 开始");
            for (int i = 1; i <= 10; i++) {
                container.add(new Object());
                System.out.println("add + " + i);
                if (container.size() == 5) {
                    //开门，执行T2
                    LockSupport.unpark(t2);
                    //让t1等t2执行完
                    LockSupport.park();
                }
            }
            System.out.println("T1 结束");
        }, "T1");
        t1.start();
    }
李王家的翠花
关注
专栏目录
204道高频Java面试题❤️五万字❤️全路线十八个模块❤️面试10多家中大厂后的总结（建议收藏）
公号：一条coding
09-13 1万+
整理了两周
最强面试题整理第二弹：Python 进阶面试题（附答案）
Rocky0429
08-17 6015
大家好呀，我是 Rocky0429。 Python 面试的时候，会涉及到很多的八股文，我结合自己的经验，整理Python 最强面试题。 Python 最强面试题主要包括以下几方面： Python 基础（已完成） Python 进阶（已完成） Python 后台开发 爬虫 机器学习 对每道面试题会附带详细的答案，无论是准备面试还是自己学习，这份面试题绝对值得你去看，去学习。 1、Python 中类方法、类实例方法、静态方法有何区别？ 类方法：是类对象的方法，在定义时需要在上方使用“@classmetho
编程题：实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个对象到容器中，线程 2 实现监控容器中对象的个数，当个数到 5 个时，线程 2 给出提示并结束。
mabiao6822的博客
09-15 453
import java.util.ArrayList; import java.util.concurrent.TimeUnit; public class Container { volatile ArrayList<Object> list=new ArrayList<>();//volatile保证可见性 private void add(Object ob...
实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
fwfwfwfwfwfwf的博客
11-19 457
1、使用传统方式 package com.example.demo.jucpool; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import com.google.common.util.co
面试题——实现一个容器，提供两个方法，add，size * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
蓝天的博客
06-09 791
1 用wait和notify实现 public class NotifyFreeLock { volatile List lists = new ArrayList<>(); public void add(Object o) { lists.add(0); } public int size() { return lists.size(); } public static void main(St.
实现一个容器，提供两个方法，add，size；写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
qq_38041439的博客
06-17 150
多线程面试题 实现一个容器，提供两个方法，add，size；写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束 1.wait和notify实现 private static List<String> list = new ArrayList<>(); public static void main(String[] args) { Object locak = new Object();
04 面试题系列 | 编程题：实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束
程序猿杂货铺
03-18 606
题目 实现一个容器，提供两个方法，add,size。写两个线程，线程 1 添加 10 个元素到容器中，线程 2 实现监控元素的个数，当个数到 5 个时，线程 2 给出提示并结束。 用普通线程方法来实现 用 volitile 关键字实现 用 wait 和 notify 实现 使用 latch 替代 wait notify 实现 用普通线程方法来实现 public class MyContaine...
100道Java并发和多线程基础面试题大集合（含解答），这波面试稳了~
程序员白楠楠的博客
01-14 1110
# 前言 这篇文章主要是对多线程的问题进行总结的，因此罗列了100个多线程的问题。 这些多线程的问题来源于各大网站，可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍，不会去看网上的答案，因此可能有些问题讲的不对，能指正的希望大家不吝指教。整理了一份Java面试宝典完整版PDF # 100个问题汇总 1、多线程有什么用？ 一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更
多线程常见面试题
qq_43078445的博客
09-04 235
1)现在有 T1、T2、T3 三个线程，你怎样保证 T2 在 T1 执行完后执行，T3 在 T2 执行完后执行？ 这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟 悉。这个多线程问题比较简单，可以用 join 方法实现。 2)在 Java 中 Lock 接口比 synchronized 块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？ lock 接口在多线程和并发编程中最大的优势是它们为读和写分别
秋春招总结之并发多线程
weixin_44015043的博客
08-04 5240
文章目录前言1. 基础进程与线程的区别区别包含关系什么是并发编程的三要素？ 在Java中如何来保证多线程的安全运行。什么是并行，什么是并发，说一说两者之间的区别：2. 实现Java的多线程创建的四种方式：继承 Thread 类；实现Runnable接口实现 Callable 接口使用线程池Thread类与Runnable接口的比较：CallableCallable 接口3. 线程的各个状态4. 各种状态下的问题关于线程同步以及线程调度的相关方法sleep和wait的区别sleep和yield 的区别star
实现一个容器，提供两个方法add,size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数为5的时候，线程2给出提示并退出，线程1继续执行。
Forest24的博客
04-17 796
关键：容器使用volatile关键字修饰。 方法一： 使用wait(),notify()实现。 package com.example.demo; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; public class Container { //v...
一道面试题：实现一个容器，提供两个方法，add,size 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束线程2
qq_37999559的博客
01-03 196
一道面试题：实现一个容器，提供两个方法，add,size 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束线程2C](这里写自定义目录标题) 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，
【高并发面试题】实现一个容器，提供add和size两个方法，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，个数到5时，线程2给出提示并结束
最新发布
wh2880557的博客
11-30 328
【代码】【高并发面试题】实现一个容器，提供add和size两个方法，写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，个数到5时，线程2给出提示并结束。
实现一个简略ArrayList, 提供 add(), remove(), size()
muskter的博客
04-19 546
实现一个简略ArrayList, 提供 add(), remove(), size() 没有考虑太多方面，还请批评指正。 接口定义 import java.io.Serializable;public interface PArrayListIT> extends Serializable{ public int add(T t); public int remove(
多线程（八）并发容器
QG
11-23 872
并发容器
synchronized和volatile关键字
hskw444273663的博客
07-14 200
一、Demo1 1、demo1 package com.hskw.demo1; /** * synchronized关键字 * synchronized关键字锁定的是对象不是代码块,demo中锁的是object对象的实例 * 锁定的对象有两种:1.类的实例 2.类对象(类锁) * 加synchronized关键字之后不一定能实现线程安全，具体还要看锁定的对象是否唯一。 */ pu...
每天学命令<addSizeBlockage>
Tao_ZT的博客
06-22 256
addSizeBlockageaddSizeBlockage这个命令主要是添加size blockage。打size blockage的地方，resize floor...
java——多线程
Xiao__Bei的博客
10-20 212
一道题
高并发编程之面试题一
今是而昨非
05-12 3028
题目：实现一个容器，提供两个方法，add,size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。 程序一，分析下面程序能否实现 List lists = new ArrayList(); public void add(Object o) { lists.add(o); } publi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值