2024年最全多线程常见案例_多线程实现实例，阿里大牛教你自己写C C++第三方库

最新推荐文章于 2024-05-16 10:27:04 发布
最新推荐文章于 2024-05-16 10:27:04 发布
阅读量376 收藏 3
点赞数 4
文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978525/article/details/138912764
版权

img
img

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

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

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

​ 队列为空,还想从队列里拿出点啥,就会阻塞,直到队列里又有了元素.

本文基于循环队列来实现一个阻塞队列:

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;
        }
    }
}
基于阻塞队列,实现一个生产者消费者模型⌚️

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

具体:(消费水平高)

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<MyTask>{
    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<MyTask> 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(),效率来的更高.

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

img
img

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

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

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

原理就是把内核态的创建线程改成了纯用户态的创建方式,内核态创建一个线程在时间等方面不可控,而纯用户态会立马执行,各方面都可控.所以采用线程池的方式并发,可以较调用start(),效率来的更高.

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

[外链图片转存中…(img-w4Vbu0Pr-1715760756893)]
[外链图片转存中…(img-bw7Igh7j-1715760756894)]

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

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

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

2401_84978525
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于多线程的经典案例~
qq_57603004的博客
04-06 2990
关于多线程的案例
今天没事给大家写一个多线程例子
07-09
今天没事给大家写一个多线程例子 今天没事给大家写一个多线程例子
实际场景中的多线程并发编程案例
iNiBuBian的博客
12-06 7189
一、CountDownLatch CountDownLatch的用法 CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继
多线程相关实例（多线程经典应用场景）
热门推荐
瞎琢磨先生の博客
04-22 1万+
转载，from 网络，未能找到原创人员，只找到一个二手转载 https://blog.csdn.net/u013521220/article/details/79648270 一.相关知识： Java多线程程序设计到的知识： （一）对同一个数量进行操作 （二）对同一个对象进行操作 （三）回调方法使用 （四）线程同步，死锁问题 （五）线程通信 等等 二．示例一：三个售票窗口同时出售20张票; 程序分析：1.票数要使用同一个静态值 2.为保证不会出现卖出同一个票数，要java多线程同步锁。 设计思路：1.创.
多线程案例
qq_774952435的博客
03-30 1665
多线程案例
C++ Concurrency in Action_C-C++_action_thread_
09-30
通过对《C++ Concurrency in Action》的学习，读者不仅能够理解并发编程的基本原理，还能掌握编写高效、安全的多线程代码的技巧，从而在C++编程中实现更优秀的性能和可扩展性。书中的PDF文档提供了详细的讲解和实例...
111_C++_
10-03
9. **并发编程**：C++11以后的版本提供了线程库，支持多线程编程，可以利用多核处理器提高程序性能。 10. **命名空间**：命名空间用于避免标识符冲突，使代码更易于管理和理解。 以上是C++编程中的一些关键知识点...
Exploring C++ 11(2nd Edition 2013)-master_C++11_
09-30
《探索C++11（第2版，2013年）》的源代码库包含了许多关于C++11新特性的深入实例和讲解。C++11是C++编程语言的一个重大更新，引入了大量的新功能和改进，旨在提高效率、可读性和安全性。这个压缩包中的"exploring-c-...
WINDOWS核心编程_C++_
10-03
《WINDOWS核心编程_C++_》是一本专注于利用C++进行Windows系统编程的教程。Windows编程是计算机科学领域的一个重要分支，对于开发系统级应用、驱动程序或者深入理解操作系统原理至关重要。C++作为一门强大且高效的...
gtSPP_GPS伪距单点定位程序C++_GPS定位_
09-29
标题中的“gtSPP_GPS伪距单点定位程序C++_GPS定位”指的是一个使用C++编程语言实现的GPS伪距单点定位算法。在GPS（全球定位系统）技术中，伪距是地面接收器计算到卫星信号传播时间的距离估计，由于实际距离加上了...
多线程应用实例
10-09
本资源包含一个多线程应用的实例开发，希望大家能够通过该实例学习到有关的知识点。
多线程相关实例
ZJRUIII的博客
03-18 2432
文章目录一、多线程案例1.单例模式1.1 饿汉模式 一、多线程案例 1.单例模式 单例模式是一种常见的“设计模式”。在软件开发中，涉及到的场景有很多，变化也有很多。很多新手如果不加限制的乱去开发，此时会造成的麻烦会有很多。于是有很多强者就把一些常见场景的一些常见解决方案整理成一份“谱”，如果按照这个谱去开发，那么开发的代码不会差到哪里去。“谱”指的就是设计模式。 场景：代码中的有些概念，不应该存在多个实例，此时应该使用单例模式来解决。例如MySQL中的DataSource类，在一个程序中就应该只有一个实例，
多线程案例【一】
m0_62824239的博客
03-28 469
目录多线程案例单例模式饿汉模式懒汉模式一级目录二级目录三级目录 多线程案例 单例模式 单例模式是一种设计模式。 写代码时有些常见场景，设计模式就是针对这些常见场景给出的解决方案。 举例： 中午这顿饭，使用了4个碗，吃完之后，立即把这4个碗洗了【饿汉模式】 饿：着急 中午这顿饭，使用了4个碗，吃完之后，先不洗，如果晚饭只需要2个碗，就只洗2个碗即可【懒汉模式】 饿汉模式 static 修饰的成员更准确的说，应该叫“类成员”、“类属性、类方法”。不加static修饰的方法，叫做“实例成员”、“实例属性、
多线程的各种案例
qq_36074180的博客
07-09 413
实现Runable接口实现多线程 继承Thread实现多线程
多线程常见案例
奋斗
04-11 1400
多线程常见案例 实现一个线程安全的单例模式🥇 单例模式的概念就是代码中的某个类只有有一个实例,不能有多个 实际开发中常见且有用,且有些概念天生就应该是单例的,比如jdbc编程中的数据源DataSource就应该只有一个. 实际的单例模式有两个 饿汉模式(相对较为着急的就把单例给构造好了) 懒汉模式(只有在必要的时候才会把这个单例进行构造) 具体: 饿汉(自身已经线程安全): class MySingleton1{ //1.加载类时就已经将单例进行构造,所以说比较着急,所以叫饿汉
多线程经典案例
qq_54219272的博客
06-25 4420
多线程的单例模式，定时器，线程池的实现等
最全多线程四大经典案例及java多线程的实现_java 多线程经典案例，2024年最新简直无敌
最新发布
2401_84976040的博客
05-16 340
if(curTime
现代C++实现Linux多线程服务器：muduo库解析
这篇资源主要探讨了在Linux环境下使用C++进行多线程服务器端编程，并特别提到了muduo网络库。以下是对相关知识点的详细说明： 1. **多线程编程**：在多核时代，多线程编程是提升服务器性能的有效方式，它允许多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值