最新多线程常见案例_多线程实现实例(1)，C C++面试题最新2024

于 2024-05-17 00:42:52 发布
阅读量295 收藏 9
点赞数 5
文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978559/article/details/138980559
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

        tali=(tali+1)%this.elem.length;//循环公式
        this.size++;
        //每次放进去一个元素最好都能提醒一下,能拿啦!~
        locker.notify();
    }
}

//2.take(),拿出队头元素
public int take(){
    synchronized (locker){
        if(this.size==0){
            //应当陷入阻塞
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //有东西拿
        int front=this.elem[head];
        head=(head+1)%this.elem.length;//循环公式
        this.size--;
        //每次拿走一个元素,就提醒一下能放啦!~
        locker.notify();
        return front;
    }
}

}


#### 基于阻塞队列,实现一个生产者消费者模型⌚️


因为阻塞队列的存在,就像一个大坝,雨水比较多的季节,就把水蓄起来,等待干旱的季节,就可以把水放出来进行灌溉,起到了一个\*\*“削峰填谷”\*\*的目的.阻塞队列也起到了类似的功能,这里的生产者消费者模型描述的就是一个类似的过程,商品得要先生产出来,消费者才能去购买,反过来,只有消费者的消费能力足够的强,生产方才能继续生产更多的商品,否则就会出现货物囤积的现象了.


具体:(消费水平高)

class MyBlockingQueue{
private int[] elem;//先不构造了吧,让用户可以构造一个自己想要的大小
private int size;//记录有效数据的个数(此处判定慢不慢使用的的方法是看有效元素个数和数组长度之间的关系)
private int head;//记录队头下标
private int tali;//记录队尾的下标

public MyBlockingQueue(int len){
    this.elem=new int[len];
}
//写一个专用于上锁的对象
Object locker=new Object();
//主要实现两个功能,拿出来和放进去
//1.put(),对照标准库中BlockingQueue中带有的put()起的同名方法
public void put(int data){
    synchronized (locker){
        if(this.size==this.elem.length){
            //应当设置成阻塞
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //可以正常放了
        this.elem[tali]=data;
        tali=(tali+1)%this.elem.length;//循环公式
        this.size++;
        //每次放进去一个元素最好都能提醒一下,能拿啦!~
        locker.notify();
    }
}

//2.take(),拿出队头元素
public int take(){
    synchronized (locker){
        if(this.size==0){
            //应当陷入阻塞
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //有东西拿
        int front=this.elem[head];
        head=(head+1)%this.elem.length;//循环公式
        this.size--;
        //每次拿走一个元素,就提醒一下能放啦!~
        locker.notify();
        return front;
    }
}

}
public class Demo8 {
public static void main(String[] args) {
MyBlockingQueue queue=new MyBlockingQueue(10);
Thread producer=new Thread(()->{
int num=0;
while(true){
queue.put(num);
System.out.println(“生产了”+num);
num++;
try {
Thread.sleep(1000);//生产一个商品就睡一秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
producer.start();

    Thread consumer =new Thread(()->{
        while(true){
            int front=queue.take();
            System.out.println("消费了"+front);//有一个商品就消费一个商品,消费速度非常的快
        }
    });
    consumer.start();
}

}
//打印:(商品一出来就被消费咯)
生产了0
消费了0
生产了1
消费了1
生产了2
消费了2
生产了3
消费了3
生产了4
消费了4


(生产水平高)

class MyBlockingQueue{
private int[] elem;//先不构造了吧,让用户可以构造一个自己想要的大小
private int size;//记录有效数据的个数(此处判定慢不慢使用的的方法是看有效元素个数和数组长度之间的关系)
private int head;//记录队头下标
private int tali;//记录队尾的下标

public MyBlockingQueue(int len){
    this.elem=new int[len];
}
//写一个专用于上锁的对象
Object locker=new Object();
//主要实现两个功能,拿出来和放进去
//1.put(),对照标准库中BlockingQueue中带有的put()起的同名方法
public void put(int data){
    synchronized (locker){
        if(this.size==this.elem.length){
            //应当设置成阻塞
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //可以正常放了
        this.elem[tali]=data;
        tali=(tali+1)%this.elem.length;//循环公式
        this.size++;
        //每次放进去一个元素最好都能提醒一下,能拿啦!~
        locker.notify();
    }
}

//2.take(),拿出队头元素
public int take(){
    synchronized (locker){
        if(this.size==0){
            //应当陷入阻塞
            try {
                locker.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //有东西拿
        int front=this.elem[head];
        head=(head+1)%this.elem.length;//循环公式
        this.size--;
        //每次拿走一个元素,就提醒一下能放啦!~
        locker.notify();
        return front;
    }
}

}
public class Demo8 {
public static void main(String[] args) {
MyBlockingQueue queue=new MyBlockingQueue(10);
Thread producer=new Thread(()->{
int num=0;
while(true){
queue.put(num);
System.out.println(“生产了”+num);
num++;
}
});
producer.start();

    Thread consumer =new Thread(()->{
        while(true){
            int front=queue.take();
            System.out.println("消费了"+front);//有一个商品就消费一个商品,消费速度非常的快
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    consumer.start();
}

}
//打印:(生产速度明显比消费速度要快很多呀)
生产了0
生产了1
消费了0
生产了2
生产了3
生产了4
生产了5
生产了6
生产了7
生产了8
生产了9
生产了10
生产了11
消费了1
消费了2
生产了12
消费了3
生产了13




---


### 实现一个定时器🕋


#### 标准库的定时器用法📦

public class Demo9 {
public static void main(String[] args) {
Timer timer=new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println(“我是定时器执行的任务”);
}
},3000);//定时器启动之时开始计时,3后执行定时器的任务,任务执行完毕,定时器并没有关闭
}
}


所以实现一个定时器,最主要的是设计一个容器:把任务和时间做存储,其次要提供一个布置任务的schedule方法.


#### 实现一个定时器🏷

class MyTask implements Comparable{
private Runnable runnable;
private long time;//设定相较于定时器开启的时间,往后延迟多久执行任务

public MyTask(Runnable runnable, long delay) {
    this.runnable = runnable;
    this.time = System.currentTimeMillis()+delay;
}

//提供一个能让一个任务跑起来的接口
public void run(){
    runnable.run();//多态式调用,因为后续任务将是实现Runnable接口的实现类
}

public long getTime(){
    return this.time;
}

public int compareTo(MyTask o){
    return (int)(this.getTime()-o.getTime());
}

}
class Mytimer{
//1.安排一个容器能装任务,标准库中的线程安全的带有优先级的阻塞队列
private PriorityBlockingQueue queue=new PriorityBlockingQueue<>();

//2.提供一个schedule方法
public void schedule(Runnable runnable,long delay){
    MyTask task=new MyTask(runnable,delay);
    queue.put(task);
    synchronized (locker){
        locker.notify();//往堆里丢一个任务,就会让扫描线程去检查堆顶元素是不是快执行了
    }
}
Object locker=new Object();
//3.在构造时开一线程执行里头的任务,也叫扫描线程
public Mytimer(){
    Thread t=new Thread(()->{
        while(true){
            try {
                MyTask front=queue.take();//若队列为空,会陷入阻塞
                long curTime=System.currentTimeMillis();
                if(curTime<front.getTime()){
                    queue.put(front);
                    //防止忙等
                    synchronized (locker){
                        locker.wait(front.getTime()-curTime);
                    }
                }else{
                    front.run();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t.start();
}

}
public class Demo10 {
public static void main(String[] args) {
Mytimer mytimer=new Mytimer();
mytimer.schedule(new Runnable() {
@Override
public void run() {
System.out.println(“恭喜你完成了定时器哦”);
}
},3000);
}
}


**注意事项**:


1. 存放任务的容器是带有阻塞功能的优先级队列,再学堆的时候就已经说了,往堆里放自定义类型的时候,要么将自定义类实现Comparable接口,要么就专门给自定义类型写一个比较器,在构造优先级队列的时候,把这个比较器的实例丢进去进行构造,但是查看带有阻塞功能的优先级队列,发现没有只带一个比较器的构造方法,所以只能采用自定义类型实现Comparable接口的方法.
2. 构造定时器的时候就开启扫描线程,这里我们要专门处理一个忙等问题,即将wait设置一个最长等待时间,就是当前线程扫描的到堆顶元素的执行时间(绝对时间戳)还差多少,每当队列中新加入了元素,扫描线程就需要重现检查堆顶的任务是不是要执行了,所以搭配着使用了wait和notify方法


### 实现一个线程池🍰


**线程池出现的原因**:多线程并发时,也会涉及到线程的频繁创建与销毁,这也会带来一定的时间开销,那此时就产生了线程池的并发处理方式,其原理就是把内核态的创建线程改成了纯用户态的创建方式,内核态创建一个线程在时间等方面不可控,而纯用户态会立马执行,各方面都可控.所以采用线程池的方式并发,可以较调用start(),效率来的更高.


#### 标准库中的基础线程池的用法💤

public class Demo5 {
private static int num=0;
private static Object locker=new Object();
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);//指定线程池里开10个线程
for(int i=0;i<10;i++){
synchronized (locker){//防止num++不是原子的
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println("我是任务 "+num++);
}
});
}
}
}
}


#### 自己实现一个线程池🏸

class MyThreadPool{
//1.线程池里要能描述一个任务,直接使用Runnable即可
//2.组织任务,可以使用一个阻塞队列
private static BlockingQueue queue=new LinkedBlockingDeque<>();
//3.描述一个线程
static class worker extends Thread{
//1.获取到刚才阻塞队列里的任务
private BlockingQueue queue;
public worker(BlockingQueue queue){
this.queue=queue;
}

    @Override
    public void run() {

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

rker(BlockingQueue queue){
this.queue=queue;
}

    @Override
    public void run() {

[外链图片转存中…(img-FxJ5VZFy-1715877750650)]
[外链图片转存中…(img-uKG14hzb-1715877750651)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

2401_84978559
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2011最新整理JAVA、C、C++常见面试题汇总
08-03
【Java基础面试题】 1. **抽象类(abstract class)和接口(interface)的...以上是Java面试中常见的知识点，涵盖了语言基础、异常处理、多线程、类与接口等多个方面。理解和掌握这些知识点对于Java开发者来说至关重要。
实际场景中的多线程并发编程案例
iNiBuBian的博客
12-06 7378
一、CountDownLatch CountDownLatch的用法 CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继
多线程相关实例
ZJRUIII的博客
03-18 2455
文章目录一、多线程案例1.单例模式1.1 饿汉模式 一、多线程案例 1.单例模式 单例模式是一种常见的“设计模式”。在软件开发中，涉及到的场景有很多，变化也有很多。很多新手如果不加限制的乱去开发，此时会造成的麻烦会有很多。于是有很多强者就把一些常见场景的一些常见解决方案整理成一份“谱”，如果按照这个谱去开发，那么开发的代码不会差到哪里去。“谱”指的就是设计模式。 场景：代码中的有些概念，不应该存在多个实例，此时应该使用单例模式来解决。例如MySQL中的DataSource类，在一个程序中就应该只有一个实例，
多线程相关实例（多线程经典应用场景）
热门推荐
瞎琢磨先生の博客
04-22 1万+
转载，from 网络，未能找到原创人员，只找到一个二手转载 https://blog.csdn.net/u013521220/article/details/79648270 一.相关知识： Java多线程程序设计到的知识： （一）对同一个数量进行操作 （二）对同一个对象进行操作 （三）回调方法使用 （四）线程同步，死锁问题 （五）线程通信 等等 二．示例一：三个售票窗口同时出售20张票; 程序分析：1.票数要使用同一个静态值 2.为保证不会出现卖出同一个票数，要java多线程同步锁。 设计思路：1.创.
多线程经典案例
qq_54219272的博客
06-25 4501
多线程的单例模式，定时器，线程池的实现等
多线程案例
qq_774952435的博客
03-30 1684
多线程案例
C++,线程互斥，ajax+jquery实现客户与服务器连接的面试预约.zip
01-20
在C++编程中，线程互斥是多线程编程中的关键概念，它确保了对共享资源的独占访问，防止了数据竞争和不一致性。线程互斥通过使用互斥量（mutex）来实现，当一个线程获得了互斥量的所有权，其他试图获取同一互斥量的...
程序员面试100题(c,c++).zip
07-10
1. **C++面试100题.pdf**：这份文档很可能包含了100个不同的C++面试问题，涵盖C++语法、面向对象编程、模板、STL、异常处理、内存管理和多线程等方面。这些问题可以帮助求职者熟悉C++面试中常见的问题类型和考察点。...
句芒多媒体面试题_嵌入式-常用知识&面试题库_大厂面试真题.doc
08-07
以下是对这些面试题的详细解析： 1. **计算结构体的大小与对齐**：在32位系统中，由于数据对齐规则，通常变量会按照4字节边界对齐。这意味着如果结构体中有小于4字节的成员，其后的成员会根据对齐规则进行位置调整...
C++面试试题荟萃.zip
06-02
《C++面试试题荟萃》是一份集合了众多C++面试常见问题的资源包，旨在帮助求职者或技术爱好者充分准备面试，提升自己的C++技术水平。这份资料涵盖了C++的基础概念、语法特性、面向对象编程、STL使用、内存管理、多...
关于多线程的经典案例~
qq_57603004的博客
04-06 3008
关于多线程的案例
多线程四大经典案例及java多线程的实现
bug郭的博客
05-04 4100
目录本节要点单例模式饿汉模式懒汉模式阻塞队列生产者消费者模型标准库中的就绪队列阻塞队列实现定时器定时器实现线程池实现线程池案例总结 本节要点 了解一些线程安全的案例 学习线程安全的设计模型 掌握单例模式,阻塞队列,生产在消费者模型 单例模式 我们知道多线程编程,因为线程的随机调度会出现很多线程安全问题! 而我们的java有些大佬针对一些多线程安全问题的应用场景,设计了一些对应的解决方法和案例,就是解决这些问题的一些套路,被称为设计模式,供我们学习和使用! 单例模式是校招最常考的一个设计模式之一!!!
2024年最全多线程常见案例_多线程实现实例，阿里大牛教你自己写C C++第三方库
2401_84978525的博客
05-15 387
​ 队列为空,还想从队列里拿出点啥,就会阻塞,直到队列里又有了元素.
最全多线程四大经典案例及java多线程的实现_java 多线程经典案例，2024年最新简直无敌
最新发布
2401_84976040的博客
05-16 472
if(curTime
多线程案例【一】
m0_62824239的博客
03-28 473
目录多线程案例单例模式饿汉模式懒汉模式一级目录二级目录三级目录 多线程案例 单例模式 单例模式是一种设计模式。 写代码时有些常见场景，设计模式就是针对这些常见场景给出的解决方案。 举例： 中午这顿饭，使用了4个碗，吃完之后，立即把这4个碗洗了【饿汉模式】 饿：着急 中午这顿饭，使用了4个碗，吃完之后，先不洗，如果晚饭只需要2个碗，就只洗2个碗即可【懒汉模式】 饿汉模式 static 修饰的成员更准确的说，应该叫“类成员”、“类属性、类方法”。不加static修饰的方法，叫做“实例成员”、“实例属性、
多线程经典代码案例及手动实现
LxinY213的博客
10-04 752
关于多线程编程的经典代码案例----单例模式,阻塞队列,定时器,线程池的分析及手动实现.
多线程常见案例
奋斗
04-11 1421
多线程常见案例 实现一个线程安全的单例模式🥇 单例模式的概念就是代码中的某个类只有有一个实例,不能有多个 实际开发中常见且有用,且有些概念天生就应该是单例的,比如jdbc编程中的数据源DataSource就应该只有一个. 实际的单例模式有两个 饿汉模式(相对较为着急的就把单例给构造好了) 懒汉模式(只有在必要的时候才会把这个单例进行构造) 具体: 饿汉(自身已经线程安全): class MySingleton1{ //1.加载类时就已经将单例进行构造,所以说比较着急,所以叫饿汉
关于C++ 多线程和并发编程问题的案例
nihao_2014的博客
12-16 37
原文链接：https://blog.csdn.net/weixin_59383576/article/details/133923034。版权声明：本文为CSDN博主「知孤云出岫」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。这些案例涉及了竞态条件和死锁等多线程编程中常见的问题，通过合适的同步机制和锁的使用，可以避免或减轻这些问题的发生。问题描述：多个线程同时访问并修改共享资源，导致不可预测的结果。解决方法：使用互斥锁（std::mutex）保护共享资源。
美国IT巨头面试题集：多线程、内存管理与异常处理
"这是一份整理自MITBBS的美国IT大公司，如GOOGLE、微软等面试题集，涵盖了多方面的技术知识点，主要涉及线程管理、内存分配、C++特性、操作系统原理、异常处理、并发编程以及设计模式等方面。" 在准备美国IT大公司...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值