多线程与高并发

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量278 收藏 2
点赞数 3
分类专栏： java 视频笔记 文章标签： java 多线程与高并发 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjh874024173/article/details/90754125
版权
  1. 线程安全问题
  2. 线程安全问题的解决方案
  3. 数据库事务解析
  4. 原生线程安全的容器
  5. 线程池的使用
  6. 线程的优先级以及线程间的协调
  7. 守护线程的解析
  8. fork-join框架的使用

多线程与高并发

一、线程安全问题

  1. 多线程的环境 --> 将多线程并发访问改成排队机制 --> 加锁
  2. 多个线程操作一个资源 --> 保证多个线程操作的是多个资源 --> 每个线程操作单独的资源，大家互不影响

二、线程安全问题的解决方案

1、加锁（java对象锁）
  1. 自旋锁
    – 还未得到锁的线程不断尝试获取锁，这种行为就是自旋（性能高，资源浪费，可能存在有线程永远获取不到锁）
    – 适合同步块内的操作不是很耗时
  2. 互斥锁
    – 还未得到锁的线程进入等待，上一个线程释放锁时它再去做获取锁的尝试。
    – 适合同步块内的操作比较耗时
  3. 公平锁
    – 各线程严格按照队列顺序去得到锁
  4. 非公平锁
    – 各线程不严格按照队列顺序去得到锁
    – synchronized是非公平锁,Lock-Condition默认是非公平锁，构造方法可切换成公平锁
  5. CAS–乐观锁
    – java.util.concurrent.atomic包下的AtomicInteger等是基于CAS乐观锁实现的
  6. 悲观锁
    – synchronized就是悲观锁，这种线程一旦获取锁，别的线程必须挂起
    – synchronized未得到锁的线程
    自旋若干次 --> 进入等待 --> 反复 --> 得到主线程释放锁的信号后再次尝试自旋若干次 --> 得到锁

非公平锁或公平锁ReentrantLock的使用示例：

/***
 * @Author zzz_欢欢欢
 * synchronized锁 --> 非公平锁 ---> 自适应自旋（先进行自旋，队列过长进行排队机制）
 * Lock锁实现：Lock lock = new ReentrantLock(); 作为参数传入对象 lock()->锁，unlock()->解锁
 */
public class Demo1_Main {
    public static void main(String[] args) {
        //构造函数传入false变成公平锁
        Lock lock = new ReentrantLock();
        //唯一的一家店，两个客户正在购买这家店的商品
        Thread th_1 = new Thread(() -> {
            Demo1 demo1 = new Demo1(lock);
            while (true) {
                demo1.sale();
                Demo_Public.sleep();
            }
        });
        Thread th_2 = new Thread(() -> {
            Demo1 demo2 = new Demo1(lock);
            while (true) {
                demo2.sale();
                Demo_Public.sleep();
            }
        });
        th_1.start();
        th_2.start();
    }
}
class Demo1 {
    //可以假定为一个店铺的库存，一个人的账户余额等等,因为他是多对象公用一个值所以必须是static
    private static Integer number = 100;
    private Lock lock;
    public Demo1(Lock lock) {
        this.lock = lock;
    }
    //销售货物场景
    public void sale() {
        lock.lock();
        try{
        	number--;
        	System.out.println(Thread.currentThread().getName() + " 卖出一个，当前数量为：" + number);
        }finally{
        	lock.unlock();
        } 
    }
}

悲观锁-非公平锁synchronized使用示例：

/***
 * @Author zzz_欢欢欢
 */
public class Demo2_Main {
    public static void main(String[] args){
        //唯一的一家店，两个客户正在购买这家店的商品
        Demo2 demo = new Demo2();
        Thread th_1 = new Thread(() -> {
            while (true){
                demo.sale();
                Demo_Public.sleep();
            }
        });
        Thread th_2 = new Thread(() -> {
            while (true){
                demo.sale();
                Demo_Public.sleep();
            }
        });
        th_1.start();
        th_2.start();
    }
}
class Demo2{
    //可以假定为一个店铺的库存，一个人的账户余额等等
    //因为其是非static所以在外部多线程中如果实例化多个对象操作的不是同一个number
    private Integer number = 100;
    //static 变量多对象唯一，作为唯一锁 synchronized（this）如果使用this 对象在堆中不唯一就失去了锁的意义。
    //synchronized（必须保证唯一）
    static Object lock = new Object();
    //销售货物场景
    public void sale(){
        synchronized (lock){
            number --;
            System.out.println(Thread.currentThread().getName()+" 卖出一个，当前数量为："+number);
        }
    }
}

java内部自实现CAS乐观锁例子：

/***
 * @Author zzz_欢欢欢
 */
public class Demo3_Main {

    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        Thread th_1 = new Thread(()->{
           while (true){
               System.out.println(Thread.currentThread().getName()+" 当前值："+demo3.sale());
               Demo_Public.sleep();
           }
        });
        Thread th_2 = new Thread(()->{
            while (true){
                System.out.println(Thread.currentThread().getName()+" 当前值："+demo3.sale());
                Demo_Public.sleep();
            }
        });
        //设置优先级-->优先也是可能性优先不一定th_1线程一定比th_2线程先执行
        th_1.setPriority(10);
        th_2.setPriority(1);
        th_1.start();
        th_2.start();
    }
}

class Demo3{
    //假定为库存
    AtomicInteger number = new AtomicInteger(0);
    public int sale(){
        return number.getAndAdd(1);
    }
}

原子包AtomicInteger示例执行结果

2、线程封闭
  1. 栈封闭
    – 全局变局部 gc回收处理的是堆内存，栈释放是出了方法自动释放。
    – js的闭包例外，方法级别的变量不释放
    例如：Struts2的C层对象是非单例，获取的变量值是全局变量进行获取，SpringMVC使用的是单例模式，通过局部变量获取前端入参。
  2. ThreadLocal
    – 用ThreadLocal包装一个变量，那么对于不同的线程来说，线程中的变量都是独立的。
/***
 * @Author zzz_欢欢欢
 */
public class Demo4_Main {
    public static void main(String[] args) {
        Thread th_1 = new Thread(()->{
            while (true){
                Integer integer = Demo.addAndReturn(Demo.threadLocal);
                System.out.println(Thread.currentThread().getName()+":"+integer);
                Demo_Public.sleep();
            }
        });
        Thread th_2 = new Thread(()->{
            while (true){
                Integer integer = Demo.addAndReturn(Demo.threadLocal);
                System.out.println(Thread.currentThread().getName()+":"+integer);
                Demo_Public.sleep();
            }
        });
        th_1.start();
        th_2.start();
    }
}
class Demo{
    static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 100);

    public static Integer addAndReturn(ThreadLocal<Integer> threadLocal){
        threadLocal.set(threadLocal.get() + 100);
        return threadLocal.get();
    }
}

输出：
在这里插入图片描述

三、数据库事务解析

  1. 数据库的四大特性
    – ACID 原子性(Atomicity)，隔离性(Isolation)，一致性(Consistency)，持久性(Durability)
    – 业务的实现以一致性为最终宗旨
    – 数据库的原子性加上隔离性可以保证一致性，但需要极高的隔离级别。（不推荐）
  2. 数据库事务的隔离级别
    – Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。（效率极低，不推荐）
    – Repeatable read (可重复读)：可避免脏读、不可重复读的发生。
    – Read committed (读已提交)：可避免脏读的发生。（常用）
    – Read uncommitted (读未提交)：最低级别，任何情况都无法保证。
  3. 数据库乐观锁的实现
select version;
update tb set col="" and version=version+1 where id="" and version="";
  1. 数据库悲观锁的实现
select * from tb where a='' for update;

– 如果查询条件是唯一索引for update 会变成行级锁，否则是表级锁。

四、原生线程安全的容器

  1. 非并发包
    – Vector
    – HashTable 性能偏低
  2. 并发包
    – CopyOnWriteArrayList 写时拷贝-读多写少的场合
    – ConcurrentHashMap jdk1.8之前使用的是分段锁机制（默认16个数据段Segment<K,V>），在1.8中去除了这个限制，以锁定头结点的方式进行保证线程安全性，性能优势：对于不同节点的数据不需要争抢同一把锁，相当于Map的下标有多少就有多少的锁。

在这里插入图片描述
jdk1.8之前ConcurrentHashMap的put方法实现逻辑：
   1) put时通过内部segmentFor(k)计算一个值，把kv放入某个Segment中
   2) 外部多线程中只要不是操作一个数据段就不需要争抢同一把锁所以性能比HashTable好

五、线程池的使用

ExecutorService对象的submit()方法可以接收Runnable对象和Callable对象
execute()方法只能接收Runnable对象
–执行Runnable对象 无返回值
–执行Runnable对象 可获得返回值
如果需要调用有返回值，只能使用submit方法传入Callable对象。

无界限线程池/固定数量线程池/单线程池/计划线程池
线程的停止/挂起为什么不提倡使用 stop()/suspend()
   – stop()会在结束立马释放锁
   – suspend()在结束不会释放锁
   – 正确的方式是加标志位，通过标志位的值来停止线程使其自然结束。

线程池类型参考博客地址：线程池种类以及具体功能说明

/***
 * @Author zzz_欢欢欢
 */
public class Demo1_Main {

    public static void main(String[] args) {
        //无界限线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        //固定数量线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
        //单线程池 单任务执行场景，新任务进入排队
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        //计划线程池-->周期性任务场景
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(10);
        //无返回值 execute
        cachedThreadPool.execute(() -> System.out.println(Thread.currentThread().getName()));
        //必有返回值，但如果传入的是Runnable对象返回值为null submit
        Future<Object> submit = cachedThreadPool.submit(() -> null);

    }
}

class Caller implements Callable<Object> {
    @Override
    public Object call() throws Exception {
        return null;
    }
}

class Runnabler implements Runnable {
    @Override
    public void run() {

    }
}

六、线程的优先级以及线程间的协调

示例题目：三个线程同时启动，一个线程单独打印A 一个线程B 一个线程C 如何保证正确按顺序输出ABC，不断进行循环输出。
附上源码：
step1：主方法：

package threadsPrint;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/***
 * @Author zzz_欢欢欢 
 */
public class MainClass {
    //创建一把锁，让三个线程去抢这把锁然后进行打印
    Lock lock = new ReentrantLock();
    //获得每个线程的状态，唤醒线程 or  让线程继续等待
    Condition conditionA = lock.newCondition();
    Condition conditionB = lock.newCondition();
    Condition conditionC = lock.newCondition();
    //设定当前打印的值 ---> 如果当前打印的是A那么下次打印只允许是B，打印完将当前值改成B
    //volatile 每次改变完当前值，立马刷入主内存
    volatile String currNeedPrintStr = "A";

    public static void main(String[] args) {
        MainClass mainClass = new MainClass();
        ThreadA threadA = new ThreadA(mainClass);
        ThreadB threadB = new ThreadB(mainClass);
        ThreadC threadC = new ThreadC(mainClass);
        threadA.start();
        threadB.start();
        threadC.start();

    }
}

三个线程：
A线程：

/***
 * @Author zzz_欢欢欢 
 */
public class ThreadA extends Thread {

    private MainClass mainClass;
    
    public ThreadA(MainClass mainClass){
        this.mainClass = mainClass;
    }
    @Override
    public void run() {
        while (true){
            //获取锁
            mainClass.lock.lock();
            try {
	            //如果当前需要打印的标识是A的话进入
	            if (mainClass.currNeedPrintStr.equals("A")){
	                //打印A
	                System.out.print("A");
	                //将标识位改成B
	                mainClass.currNeedPrintStr = "B";
	                //将B线程唤醒
	                mainClass.conditionB.signal();
	                Thread.sleep(1000);
	            }
                //A线程进入等待，等待被唤醒
                mainClass.conditionA.await();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
				//释放锁
	            mainClass.lock.unlock();
			}
        }
    }
}

B线程：

/***
 * @Author zzz_欢欢欢 
 */
public class ThreadB extends Thread {

    private MainClass mainClass;

    public ThreadB(MainClass mainClass) {
        this.mainClass = mainClass;
    }

    @Override
    public void run() {
        while (true) {
            mainClass.lock.lock();
            try {
	            if (mainClass.currNeedPrintStr.equals("B")) {
	                System.out.print("B");
	                mainClass.currNeedPrintStr = "C";
	                mainClass.conditionC.signal();
	                try {
	                    Thread.sleep(1000);
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
	            }
	            mainClass.conditionB.await();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
 				mainClass.lock.unlock();
			}
        }
    }
}

C线程：

/***
 * @Author zzz_欢欢欢 
 */
public class ThreadC extends Thread {

    private MainClass mainClass;

    public ThreadC(MainClass mainClass) {
        this.mainClass = mainClass;
    }

    @Override
    public void run() {
        while (true) {
            mainClass.lock.lock();
			try {
	            if (mainClass.currNeedPrintStr.equals("C")) {
	                System.out.print("C ");
	                mainClass.currNeedPrintStr = "A";
	                mainClass.conditionA.signal();
	                try {
	                    Thread.sleep(1000);
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
	            }
                mainClass.conditionC.await();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
				mainClass.lock.unlock();
			}
        }
    }
}

priority()线程优先级： 数字越大优先级越高，但也无法保证百分百，只能大概进行标识哪个线程优先。
Lock-condition中的 Condition可以实现优先级准确
condition.signal()空叫(唤醒)
condition.await()等待

七、守护线程的解析

thread.setDaemon(true) 守护线程，监控其他活动线程，其他活动线程结束，守护线程没有存在的意义了也就结束了。

八、fork-join框架的使用

场景： 1+2+3+4+5+6…+100
将这个加法任务拆成10个任务，由十个线程进行执行。
1、把一个大任务，拆分成多个子任务（fork），多个线程并行执行子任务，归并结果（join）
2、海量层级的文件夹树递归
3、了解一下工作窃取模式 fork-join内部已经实现了工作窃取模式。
工作窃取模式：当十个任务执行时，如果一个线程工作效率特别快，会从别的队列里窃取任务去执行。
– ForkJoinPool对象去执行RecursiveTask对象
– 自己实现一个RecursiveTask，重写compute方法
– compute()内做分支，分支1是不可拆分的任务，直接运算出结果。分支2是可拆分任务，调用本Task类制造小任务列表。
– 最后是归并并返回结果。
代码示例：

/***
 * @Author zzz_欢欢欢
 */
public class Demo_Main {
    //将1+2+3+....+100拆成10个子任务进行
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Integer> submit = pool.submit(new MyTask(1, 100));
        System.out.println(submit.get());
    }
}

class MyTask extends RecursiveTask<Integer> {
    private Integer start;
    private Integer end;
    //每个线程执行任务的重量
    private Integer size = 10;

    public MyTask(Integer start, Integer end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= size - 1) {
            return (start + end) * (end - start + 1) / 2;
        } else {
            List<MyTask> myTaskList = Lists.newArrayList();
            for (int i = start; ; i = i + size) {
                //非size的倍数在最后一次相加时进行跳出循环判断
                if (end - i >=0 && end - i<=size -2){
                    MyTask myTask = new MyTask(i, end);
                    myTaskList.add(myTask);
                    break;
                }
                MyTask myTask = new MyTask(i, i + size - 1);
                myTaskList.add(myTask);
                //如果分组算的末数和end相等说明是最后一个Task
                if (i + size - 1 == end)break;
            }
            invokeAll(myTaskList);
            AtomicInteger sum = new AtomicInteger();
            myTaskList.forEach(e -> sum.set(sum.get() + e.join()));
            return sum.get();
        }
    }
}```
zzz_欢欢欢
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Kvrocks: 一款开源的企业级磁盘KV存储服务
weixin_45583158的博客
06-17 1306
Kvrocks 是基于 RocksDB 之上兼容 Redis 协议的 NoSQL 存储服务，设计目标是提供一个低成本以及大容量的 Redis 服务，作为 Redis 在大数据量场景的互补服...
多线程与高并发实战手册.rar
03-20
本文将基于《多线程与高并发实战手册》中的知识点，深入探讨这两个主题。 首先，多线程是指在一个程序中同时运行多个线程，这使得程序能够并行处理任务，提高系统的效率和响应速度。Java、Python、C++等编程语言都...
使用多线程模拟真实高并发业务并保证安全性（一）
Q526859236的博客
08-11 239
前言 兄弟篇：Java——使用多线程模拟真实高并发业务并保证安全性（二） 一、需求 使用100个线程往list中添加10000条数据，要求保证安全性，并正确记录数量。 二、实现 在看下面的代码之前，读者朋友可以自己先试一试怎么实现上面的需求，然后跟本文的实现方式对比一下。 2.1 使用技术 可重入锁ReentrantReadWriteLock，这里没有使用到CopyOnWriteArrayList，因为ReentrantReadWriteLock已经起到了CopyOnWriteArrayList对容器add
实现键值对存储（一）：什么是键值对存储，为什么要实现它
搞搞Android 玩玩前端
08-26 9703
译自：codecapsule.com 这是Emmanuel Goossaert实现自己的键值对存储的记录系列文章。预计是10个部分，截至2014-8-26只完成了6个部分。 本文是本系列的第一部分。 Emmanuel Goossaert另一个比较受欢迎的系列是《为SSD编程》，博客中有这个系列的全部翻译。
JavaScript存在多线程吗
yuyongkun4519的博客
06-04 640
最近看到这样一个面试题，js有多线程吗，毫无疑问js本身只能单线程运行，因此并不支持多线程，下面我们就来分析一下： 首先在浏览器中至少会有三个线程：js引擎线程（处理js）、gui渲染线程（页面渲染）、浏览器时间触发线程（控制交互） 因为js可以操作dom元素，进而会影响到gui的渲染结果，因此js引擎线程与gui渲染线程是互斥的，也就是说当js引擎线程处于工作状态时，gui渲染线程是冻结的。...
【多线程与高并发】- 浅谈volatile
qq_43843951的博客
02-24 21万+
volatile是Java语言中的一种轻量级的同步机制，它可以确保共享变量的内存可见性，也就是当一个线程修改了共享变量的值时，其他线程能够立即知道这个修改。
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
[并发概念] 多线程与高并发
大唐雨夜的博客
12-31 1557
多线程的理解 什么是多线程 如果一个程序允许两个或者两个以上的线程，那么它便是多线程程序。多线程是指单个进程内允许多个线程。 任务分为资源独立任务和资源共享任务。独立任务不需要使用多线程；共享任务，会使用到进程共享资源，需要保证线程安全。 场景理解：房子与租客 假设有一套房子，住着我和我的几个室友，房子比喻进程，我和室友比喻线程。房子中有很多公共空间，例如厨房、客厅，每个人都可以到客厅来。厨房和客...
多线程与高并发基础
qq_61557294的博客
08-24 5069
本文总结了多线程与高并发中相对基础的内容，对于想要深入学好多线程与高并发的你来说绝对有用！！
Python多线程与高并发
you are sherlocked by me!
02-28 1万+
主要讲解了关于Python多线程的一些例子和高并发的一些应用场景# -*- coding: utf-8 -*- # @Author: Clarence # @Date: 2018-02-28 20:39:31 # @Last Modified by: Clarence # @Last Modified time: 2018-02-28 23:29:54 """ 涉及知识点 互斥锁 线程 在...
Socket多线程与高并发
qq_37515544的博客
04-15 2383
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 多线程与高并发一、BIO（block input output)阻塞式的输入和输出二、NIO（non-blocking input output）非阻塞式输入输出2.1 NIO问题2.2 多路复用器三、使用Netty其他知识 一、BIO（block input output)阻塞式的输入和输出 按照此代码可以写一个简单的服务端接收代码 cmd连接服务端 发送消息到服务端 服务端接收 问题 c10k问题（10w个线程会大大.
多线程与高并发-电子.pdf
05-03
马士兵老师课程笔记 https://www.bilibili.com/video/BV1of4y1p74A?p=45
多线程与高并发程序
11-27
该资源是马老师在2018年公开课所使用的程序版本，课程中详细的介绍了线程，以及线程和线程池的使用。仅供各位学习和参考使用，希望对大家来说有所帮助。
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
在这个名为"人工智能-项目实践-多线程-多线程与高并发.zip"的压缩包中，我们可以推测它可能包含了关于如何在AI项目中应用多线程技术以实现高效并发处理的资源，比如代码示例、教程或者研究报告。 多线程是指在一个...
多线程与高并发编程笔记、源码等
09-05
标题“多线程与高并发编程笔记、源码等”表明了资源的核心内容，涵盖了多线程和高并发编程的理论与实践。多线程允许一个应用程序同时执行多个任务，而高并发则指系统能够处理大量并发请求的能力。这两个概念在现代...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 469
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 570
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 684
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1188
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
多线程与高并发 pdf下载
01-02
多线程是一种同时进行多个任务的技术，通过将任务分解成多...综上所述，多线程和高并发技术能够有效地提升PDF下载的效率和用户体验，但在实际应用中需要综合考虑线程安全、系统性能等因素，才能实现高效的PDF下载功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值