多线程面试题

最新推荐文章于 2024-04-16 10:36:17 发布
最新推荐文章于 2024-04-16 10:36:17 发布
阅读量283 收藏 1
点赞数
分类专栏： Java多线程 文章标签： 多线程之间的通信 多线程 
【问题】实现一个容器，提供两个方法，add，size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。

（1）解决方案1

/**
 * 曾经的面试题：（淘宝？）
 * 实现一个容器，提供两个方法，add，size
 * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。
 * <p>
 * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
 *
 * @author mashibing
 */
package yxxy.c_019;

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

public class MyContainer2 {
    //添加volatile，使t2能够得到通知
    private volatile List lists = new ArrayList();

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

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        MyContainer2 c = new MyContainer2();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

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

（2）解决方案2

/**
 * 曾经的面试题：（淘宝？）
 * 实现一个容器，提供两个方法，add，size
 * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
 * <p>
 * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
 * <p>
 * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
 * <p>
 * 阅读下面的程序，并分析输出结果
 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
 * 想想这是为什么？
 *
 * @author mashibing
 */
package yxxy.c_019;

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


public class MyContainer3 {
    //添加volatile，使t2能够得到通知
    private volatile List lists = new ArrayList();

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

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        MyContainer3 c = new MyContainer3();

        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2启动");
                if (c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
            }

        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);

                    if (c.size() == 5) {
                        lock.notify();
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

（3）解决方案3

/**
 * 曾经的面试题：（淘宝？）
 * 实现一个容器，提供两个方法，add，size
 * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
 * <p>
 * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
 * <p>
 * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
 * <p>
 * 阅读下面的程序，并分析输出结果
 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
 * 想想这是为什么？
 * <p>
 * notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
 * 整个通信过程比较繁琐
 *
 * @author mashibing
 */
package yxxy.c_019;

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

public class MyContainer4 {
    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();

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

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        MyContainer4 c = new MyContainer4();

        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2启动");
                if (c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
                //通知t1继续执行
                lock.notify();
            }

        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);

                    if (c.size() == 5) {
                        lock.notify();
                        //释放锁，让t2得以执行
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

（4）解决方案4

/**
 * 曾经的面试题：（淘宝？）
 * 实现一个容器，提供两个方法，add，size
 * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
 * <p>
 * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
 * <p>
 * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
 * <p>
 * 阅读下面的程序，并分析输出结果
 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
 * 想想这是为什么？
 * <p>
 * notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
 * 整个通信过程比较繁琐
 * <p>
 * 使用Latch（门闩）替代wait notify来进行通知
 * 好处是通信方式简单，同时也可以指定等待时间
 * 使用await和countdown方法替代wait和notify
 * CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
 * 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
 * 这时应该考虑countdownlatch/cyclicbarrier/semaphore
 *
 * @author mashibing
 */
package yxxy.c_019;

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

public class MyContainer5 {
    // 添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();

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

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        MyContainer5 c = new MyContainer5();

        CountDownLatch latch = new CountDownLatch(1);

        new Thread(() -> {
            System.out.println("t2启动");
            if (c.size() != 5) {
                try {
                    latch.await();

                    //也可以指定等待时间
                    //latch.await(5000, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t2 结束");

        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        new Thread(() -> {
            System.out.println("t1启动");
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);

                if (c.size() == 5) {
                    // 打开门闩，让t2得以执行
                    latch.countDown();
                }

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }, "t1").start();

    }
}

 

风暴计划
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【021期】面试官问，c#多线程面试题及答案
2401_84102864的博客
04-10 560
Java架构进阶面试及知识点文档笔记这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理Java分布式高级面试问题解析文档其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！互联网Java程序员面试必备问题解析及文档学习笔记Java架构进阶视频解析合集一个人可以走的很快，但一群人才能走的更远。
C#多线程复习题目80道+答案
10-10
此资源有利于初学者巩固C#多线程的基础知识，内有80道练习题及答案。
JAVA多线程实现两个线程，线程1负责向容器中添加10个元素，线程2负责监控容器中元素个数，当个数为5时，线程2给出提示并且结束
kunkunliu的博客
05-07 387
JAVA多线程实现两个线程，线程1负责向容器中添加10个元素，线程2负责监控容器中元素个数，当个数为5时，线程2给出提示并且结束 实现一个容器 提供两个方法 add和size 写两个线程，线程1添加10个元素到容器中，线程2实现监控容器中元素的个数，当个数到5个时，线程2给出提示并且结束 实现方式LockSupport中的park （阻塞线程）方法和unpark(Thread) （重新唤醒某个线...
经典C#面试：C#下多线程的实现方式与区别详解，包括并行编程和并发编程
qq_35320456的博客
01-25 1679
经典C#面试：一文带你了解C#下多线程的实现方式与区别详解，包括并行编程和并发编程
.NET/C#⾯试题汇总系列：多线程【面试必须掌握的一项知识】
weixin_45091053的博客
10-04 3240
小编之前毕业找工作面试的公司，基本上每家公司都有提问到多线程，而多线程在大学里基本上都是没有涉及，或者涉及不深，又或者平时的自主练习基本没有涉及这块的内容，因此这个多线程系列是面试前必须要掌握的，临时抱佛脚也是可以的（就目前来说，多线程在大公司里面都是封装好的，基本上就是学习使用的问题，但是多线程的基本知识还是要了解的）
哈哈iOS多线程面试题
05-19
iOS多线程面试题
15个高级Java多线程面试题及回答
09-04
以下是一些高级Java多线程面试题及其涉及的知识点： 1. **如何保证线程执行顺序？** - 使用`Thread.join()`方法可以使一个线程等待另一个线程完成后再继续执行，以此来控制线程的执行顺序。 2. **Lock接口相比于`...
CSharp多线程的详细教程
05-04
CSharp多线程的详细教程,CSharp多线程的详细教程
C#面试题 包括 ADO.net 多线程等
10-13
C#面试题 包括 ADO.net 多线程等 C#面试题 包括 ADO.net 多线程等 C#面试题 包括 ADO.net 多线程等 C#面试题 包括 ADO.net 多线程等 C#面试题 包括 ADO.net 多线程等
面试常考：C#用两个线程交替打印1-100的五种方法
忧郁的蛋的专栏
05-23 628
以下是对五种方法的简单比较和说明：1、使用ManualResetEventWaitHandle：这种方法在实现上较为简单，但是由于线程必须互斥地访问共享资源，因此会导致性能瓶颈。1、C#编程语言和语法：实现多线程程序需要熟悉C#编程语言和语法，包括线程的创建和管理、共享资源的访问和同步等方面的知识。2、多线程编程：多线程编程是指同时运行多个线程的编程模型，它可以提高应用程序的性能和响应能力。3、线程同步机制：线程同步机制是指用于控制多个线程访问共享资源的机制，常用的线程同步机制包括锁、信号量、事件等。
【多线程】精品面试题61道
ADbyCool的博客
05-29 1810
在多线程编程中，伪共享指的是多个线程在同时访问不同但是在同一缓存行中的变量，由于缓存行的一致性协议，这些变量的访问会相互影响，导致性能下降。在现代计算机体系结构中，内存系统一般被分为若干个缓存行，每个缓存行的大小通常为 64 字节。当多个线程并发访问不同但是在同一缓存行中的变量时，会导致缓存一致性协议的频繁通信，从而降低程序的性能。例如，如果两个变量a和b在同一个缓存行中，线程 1 修改了变量a的值，线程 2 修改了变量b的值，这会导致缓存一致性协议将缓存行的数据全部刷回到主内存中，从而影响程序的性能。
C#面试题及详细解析
2301_76965813的博客
04-08 2564
这种设计导致yield不可重入，只要其迭代过一次，就无法重新迭代了，需要注意。5、骚操作方面，stackful可以轻松实现完全一致的递归/异常处理等，没有任何影响，但stackless需要编译器作者高超的技艺才能实现(如C#的作者)，注意最初的C#5.0在try-catch块中是不能写await的。2、首先是解析阶段的表达式树，C#编译器在编译时，它会将这些语句以表达式树的形式保存起来，在求值时，C#编译器会将所有的表达式树翻译成求值方法(如在数据库中执行SQL语句)。
C#常用面试题
itzhangzx的博客
06-21 9174
请记住，在面试过程中，不仅仅是回答问题，还要展示您的思考过程、编程经验和解决问题的能力。它将现实世界中的事物抽象成对象，通过定义对象的属性（数据）和行为（方法），以及对象之间的关系和交互，实现软件系统的模块化、可维护性和可扩展性。在C#中，属性（Property）是一种特殊的成员，用于封装类的字段，并提供对其读取和写入的访问方式。e. 抽象类和接口：C#提供抽象类和接口的概念，抽象类允许定义一些方法的实现并提供派生类重写的虚方法，接口定义一组方法的契约，类可以实现一个或多个接口。
面试必备：C#多线程技术
weixin_68436326的博客
09-14 138
进程与线程进程是应用的执行实例，可狭义理解为一个应用程序就是一个进程。启用一个应用程序时就是启动了一个进程。该应用运行所需的所有地址空间，代码，数据及系统资源都属于此进程。进程所使用的所有资源会在进程终止时被释放或关闭。线程是进程内部的一个执行单元。启动进程的同时就会启动该进程的主线程。一个进程可以包含很多线程。线程分类线程有很多种分类从系统回收的角度来说可分为前台线程和后台线程1、前台线程前台线...
38道多线程核心面试题（附答案）
最新发布
DN金猿的博客
04-16 1042
今天给大家分享的是比较全面的多线程面试题，大家在面试的过程中不免会被问到很多专业性的问题，有的时候回答的并不是那么全面和精细，这仅仅代表个人观点。
多线程面试题详解：同步、锁与高效策略
多线程面试题是求职者在技术面试中常被问到的话题，它涉及操作系统中的核心概念和并发编程中的关键挑战。以下是一些重要的知识点： 1. 线程基础： - 线程是操作系统调度的基本单元，是进程内的执行实体，通过多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值