精华内容
下载资源
问答
  • 1、常用的设计模式 单例模式 一个类只能构造出一个实例。即如果实例化,只能实例化一次 实现:使用一个变量来标识该类是否被实例化 例如我们实现弹窗,点击的时候创建一个div元素,如果频繁点击就会不断的创建和...

    参考:JavaScript 中常见设计模式整理
    详解 Javascript十大常用设计模式

    1、常用的设计模式

    1. 单例模式
      • 一个类只能构造出一个实例。即如果有实例化,只能实例化一次
      • 实现:使用一个变量来标识该类是否被实例化
      • 例如我们实现弹窗,点击的时候创建一个div元素,如果频繁点击就会不断的创建和删除,此时使用单例模式则只会实例化一次
    2. 策略模式
      • 定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换
      • 根据不同的参数可以命中不同的策略,例如动画库里的算法函数
    3. 代理模式
      • 代理对象和本体对象具有一致的接口,例如图片预加载
      • 代理是一个对象,它可以用来控制对本体对象的访问,它与本体对象实现了同样的接口,代理对象会把所有的调用方法传递给本体对象的
      • 本地对象注重的去执行页面上的代码,代理则控制本地对象何时被实例化,何时被使用
      • 优点:代理对象可以代替本体被实例化,并使其可以被远程访问;可以把本体实例化推迟到真正需要的时候;对于实例化比较费时的本体对象,或者因为尺寸比较大以至于不用时不适于保存在内存中的本体,我们可以推迟实例化该对象
    4. 工厂模式
      • 主要为了解决实例化对象产生重复的问题。
      • 优点:可以解决多个相似的问题;缺点:不能知道对象识别的问题,即不知道是哪个对象的实例
      • 可以在父类中实现一些相同的方法,在子类中重写该父类的方法实现自己的业务逻辑
    5. 发布-订阅者模式
    6. 命令模式
      • 命令指的是一个执行某些特定事情的指令
      • 使用场景:有时候需要向某些对象发送请求,但是并不知道请求的接收者是谁,也不知道请求的操作是什么,可以使用命令模式来消除发送者与接收者的代码耦合关系。
    7. 模块模式
      • 模块模式是为单例模式添加私有变量和私有方法,能够减少全局变量的使用
      • 模块模式使用了一个返回对象的匿名函数。在这个匿名函数内部,先定义了私有变量和函数,供内部函数使用,然后将一个对象字面量作为函数的值返回,返回的对象字面量中只包含可以公开的属性和方法
    8. 职责链模式
      • 通过请求第一个条件,会持续执行后续的条件,直到返回结果为止
      • 发送者知道链中的第一个接收者,它向这个接收者发送该请求;每一个接收者都对请求进行分析,然后要么处理它,要么它往下传递;每一个接收者知道其他的对象只有一个,即它在链中的下家(successor);如果没有任何接收者处理请求,那么请求会从链中离开。
      • 优点:消除请求的发送者与接收者之间的耦合。
    9. 模板方法模式:
    10. 中介者模式
      • 对象和对象之间借助第三方中介者进行通信
      • 中介者模式的作用是解除对象与对象之间的耦合关系,增加一个中介对象后,所有的相关对象都通过中介者对象来通信,而不是相互引用,所以当一个对象发送改变时,只需要通知中介者对象即可。
    11. 装饰者模式
    - 动态的给函数赋能
    
    1. 适配者模式
    - 一种数据结构改成另一种数据结构
    
    1. 观察者模式
    - 当观察对象发生变化时自动调用相关函数
    

    2、设计模式的六大原则

    参考:23种设计模式全解析

    总原则:开闭原则,即对扩展开放,对修改关闭

    在程序需要进行拓展的时候,不能去修改原有的代码,而是要扩展原有代码,实现一个热插拔的效果

    1. 单一职责原则:每个类应该实现单一的职责,如若不然,就应该把类拆分
    2. 里氏替换原则:子类对父类的方法尽量不要重写和重载
    3. 依赖倒转原则:写代码时用到具体类时,不与具体类交互,而与具体类的上层接口交互。
    4. 接口隔离原则
    5. 迪米特法则:只与直接的朋友通信
    6. 合成复用原则:尽量首先使用合成/聚合的方式,而不是使用继承
    展开全文
  • 设计模式有哪些?(一张图就可以了) . 项目中常用的设计模式 (1)、模板方法模式 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,如jdbcTemplate (2)、代理模式 spring的Proxy模式在AOP中有体现 (3)...

    设计模式有哪些?(一张图就可以了)
    在这里插入图片描述

    .

    项目中常用的设计模式

    (1)、模板方法模式

    定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,如jdbcTemplate

    (2)、代理模式

    spring的Proxy模式在AOP中有体现

    (3)、观察者模式

    定义对象的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新

    (4)、适配器模式

    MethodBeforeAdviceAdapter类。

    (5)、策略模式

    使用了java的继承和多态

    (6)、单例模式

    解决了一个全局使用的类频繁的创建与销毁。

    (7)、工厂模式

    分为三种:简单工厂,工厂方法,抽象工厂。

    手写生产者/消费者模式

    生产者消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一存储空间,生产者向空间里生产数据,而消费者取走数据。

    实现生产者消费者模式有三点:

    (1)、一般使用队列作为缓冲区,给生产者和消费者解耦,平衡了生产者和消费者的处理能力。

    (2)、构建生产者,队列满使得生产者线程阻塞。

    (3)、构建消费者,队列空使得消费者线程阻塞。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    BlockingQueue是一个阻塞队列,它的存取可以保证只有一个线程在进行,所以根据逻辑,生产者在内存满的时候进行等待,并唤醒消费者队列,反过来消费者在饥饿状态下,等待并唤醒生产者生产。

    写出观察者模式的代码

    为了帮助开发者了解,这里的观察者代码用了中文“新闻接受者”,被观察者用了“新闻发布者”,实际上在项目中是不能使用中文定义类名的。
    在这里插入图片描述
    在这里插入图片描述
    从上边的例子可以看出,定义了四个订阅者,一个发布者,当发布者更新一个消息时,四个订阅者都收到消息,根据发布者更新的信息执行对应的更新操作。

    展开全文
  • 计算机常用算法------第二章 枚举 (1)枚举概述 枚举法也称为列举法、穷举法,使蛮力策略的具体表现,又称为蛮力法。 枚举是一种简单而直接解决问题方法. ...算法设计比较简单,只要一一列举问题所涉及所以...

    计算机常用算法------第二章 枚举

    (1)枚举概述

    枚举法也称为列举法、穷举法,使蛮力策略的具体表现,又称为蛮力法。
    枚举是一种简单而直接解决问题的方法.

    (2)枚举的基本思想是:

    逐一列举问题所涉及的所有清醒,并根据问题提出条件的条件检验哪些是问题的解,那些应予以排除。
    枚举法常用于解决“是否存在”或“有多少种可能”等问题。

    (3)枚举的特点是

    算法设计比较简单,只要一一列举问题所涉及的所以情形即可。

    (4)枚举模式

    实施枚举通常是应用循环结构来实现

    有两种:
    1.区间枚举

        区间枚举:通过枚举循环的上下限控制枚举区间,而在循环体中完成各个运算操作,然后根据所求解的具体条件,应用选择结构实施判别与筛选,求得所要求的解。

    区间枚举设计的框架描述:

    框架描述:
    n = 0;
    for(k = <区间下限>;k<=<区间上限>;k++){   //根据实际情况控制枚举范围 
        <运算操作序列>;
        if(<约束条件>){   //根据约束条件实施筛选 
            printf(<满足要求的解>);  //逐一输出问题的解 
            n++;            //统计解的个数 
        }   
    }
    printf(<解的个数>);   //输出解的个数 

    **2.递增枚举:**
    有些问题没有明确的范围限制,可根据问题的具体情况试探地从某一起点开始增值枚举,对每一个数进行操作与判别,若满足条件即输出结果

    递增枚举设计的框架描述:

    k = 0;
    while(1){
        k++;            //设置循环,枚举变量k递增; 
        <运算操作序列>;
        if(<约束条件>){           //根据约束条件实施筛选与结束 
            printf(<满足要求的解>);   //输出问题的解 
            return ;       //返回结束 
        }
         
    }

    枚举实施步骤:

    (1)根据问题的具体情况确定枚举量(简单变量或数组)
    (2)根据问题的具体情况确定枚举范围,设置枚举循环
    (3)根据问题的具体要求确定筛选条件
    (4)设计枚举并运行、调试,对运行结果进行分析与讨论。

    (5)统计与求和

    全素组
    ···素数又称为质数,是不能被1以外的其他整数整除的整数。如2,3,5,7 2也是偶素数
    ···合数又称为复数,一个整数如果能被除1与本身以外的整数整除。
    ···注意:1既不是质数也不是偶数

    例题:例如输入n=15,输出 3+5+11=19为素数 则 3 5 11称为一个基于15的全素组

    //统计求和  应用试商判别素数
    #include<stdio.h>
    #include<math.h>
    int main(){
        int i,j,k,i2,j2,k2,n,s,t,w,z,max,p[9000],q[1500]; 
        long m;
        printf("请输入一个整数n:");
        scanf("%d",&n);
        for(int i= 0;i<= 3*n;i = i+2){
            t = 1;
            z = (int)sqrt(i);
            for(int j = 3;j<= z;j++){
                if(i%j==0){
                    t = 0;
                    break;
                }
                if(t == 1){   //奇数i为素数时标记p[i]=1 
                    p[i] = 1;
                }
                w = 0;
                for(int i = 3;i<= n;i=i+2){
                    if(p[i] == 1){
                        w++;
                        q[w] = i;    //共有w个不大于n的奇素数赋给q数组 
                    }
                }
            }
        }
                    m = 0;
                    max = 0;
                    for(int i = 1;i<= w-2;i++)  //设置三重循环枚举所有三个素数数组 
                    for(int j = i+1;j<= w-1;k++)   
                    for(int k = j+1;k<=w;k++){
                        s = q[i]+q[j]+q[k];   //统计三个元素之和 
                        if(p[s] == 1){
                            m++;
                            if(s>max){   //比较并记录最大全素组 
                                max = s;
                                i2 = q[i];
                                k2 = q[k];
                            }
                        }
                    }
                        printf("共有%ld个素组\n",m);
                        if(m>0)
                        printf("一个最大全素组为:%d+%d+%d=%ld\n",i2,j2,k2,max);
    } 

    最简真分数(分子小于分母,且分子分母无公因数)

    #include<stdio.h>
    #include<math.h>
    int main(){
        int a,b,i,j,t,u;
        long m = 0;
        double s;
        printf("最简真分母在[a,b]内,请确定a、b:");
        scanf("%d,%d",&a,&b);//输入区间上下限 
        s = 0;
        
        for(int j = a;j<= b;j++)   //枚举分母 
        for(int i = 1;i<= j-1;i++){   //枚举分子 
            for(t = 0,u = 2;u<= i;u++){  //枚举因数 
                if(j%u == 0 && i%u == 0){
                    t = 1;
                    break;   //分子分母有公因数,舍去 
                }
                if(t == 0)
                {
                    m++;//统计最简真分数个数 
                    s+=(double)i/j; //求最简真分数的和 
                }
            }
        }
            printf("最简真分数共m=%ld个。\n",m);
            printf("其和s=%.5f\n",s);
    }

    (6)解方程

    佩尔方程
    x^2+ny=1(其中n为非平方正整数)

    常把x、y中有一个为零的解称为平凡解
    x、y满足方程的最小正数的解又称为基本解

    程序设计:

    #include<stdio.h>
    #include<math.h> 
    void main(){
        double a,m,n,x,y;
        printf("解佩尔方程:x^2-ny^2=1.\n");
        printf("请输入非平方整数n:");
        scanf("%lf",&n);
        m = floor(sqrt(n+1));
        if(m*n == n){
            printf("n为平方数,方程无正整数解");
            return;
        }
        y = 1;
            y++;
            a = n*y*y;
            x = floor(sqrt(a+1));
            if(x*x == a+1){
                printf("方程x^2-%.0fy^2 = 1的基本解为:\n",n);
                printf("x = %.0f,y = %.0f\n",x,y);
                break;
            }
        }
    }

    (7)解不等式

    程序设计:

    #include<stdio.h>
    #include<math.h>
    int main(){
        long c,d,i,m1,m2;
        double s;
        printf("请输入正整数m1,m2(m1<m2):");
        scanf("%ld,%ld",&m1,&m2);
        i = 0;
        s = 0;
        while(s<= m1){
            i = i+1;
            s = s+sqrt(i)/(i+1);
        }
        c = i;
        do{
            i = i+1;
            s = s+sqrt(i)/(i+1);
        }
        while(s<=m2){
            d = i-1;
            printf("满足不等式的正整数n为:%ld<=n<=%ld\n",c,d);
        }
    } 

    转载于:https://www.cnblogs.com/qichunlin/p/8044798.html

    展开全文
  • 进程调度算法模拟与实现

    千次阅读 2019-05-21 21:18:31
    在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。 调度算法 编写允许进程并行...

    进程管理

    进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。

    调度算法

    编写允许进程并行执行的进程调度程序,在常用的进程(作业)调度算法:先来先服务算法、时间片轮转法、最高响应比优先算法、高优先权优先算法等调度算法中至少选择2种调度算法进行模拟,并输出平均周转时间和平均带权周转时间。
    本次模拟的算法为:先来先服务、非抢占式静态优先级算法

    源代码

    • 先来先服务
    #include <bits/stdc++.h>
    #include <iostream>
    #include <stdio.h>
    #include <math.h>
    #include <stdlib.h>
    #include <string>
    #include <ctype.h>
    #include <string.h>
    #include <algorithm>
    #include <vector>
    #include <queue>
    #include <set>
    #include <map>
    #include <stack>
    #define maxn 100
    using namespace std;
    
    typedef struct Node{
        char name;
        double daoda;
        double yunxing;
        double youxian;
        double start;
        double end;
        double zhouzhuan;
        double daiquan;
    }PCB;
    PCB pcb[maxn]; 
    
    bool cmp(Node a,Node b){
        return a.daoda < b.daoda;
    }
    
    //平均 
    double T;
    double S;
    int n;//进程数量
    
    
    void First(){
        cout<<endl;
        cout<<"\t\t先来先服务算法:"<<endl;
        cout<<endl;
        sort(pcb,pcb+n,cmp);//把进程根据到达的时间从小到达进行排序
        cout<<"进程运行的顺序为:"<<endl;
        cout<<pcb[0].name;
        for(int i=1;i<n;i++){
            cout<<"-->"<<pcb[i].name;
        }
        cout<<endl;
        
        double time = max(0.0,pcb[0].daoda);
        
        double t = 0;//保存周转时间的和 
        double s = 0;  //保存带权周转时间和
         
        for(int i=0;i<n;i++){
            pcb[i].start = time;
            pcb[i].end = time + pcb[i].yunxing;
            pcb[i].zhouzhuan = pcb[i].end - pcb[i].daoda;
            pcb[i].daiquan = pcb[i].zhouzhuan / pcb[i].yunxing;
            time += pcb[i].yunxing;
            
            //当这时的结束时间小于下一个进程的到达时间的话,就要重新更新time
            if(i != n-1){
                time = max(time,pcb[i+1].daoda);
            }
            //求两个和 
            t += pcb[i].zhouzhuan;
            s += pcb[i].daiquan;
            
        }
        T = t / n;
        S = s / n;
        cout<<"平均周转时间:"<<T<<endl;
        cout<<"平均带权周转时间:"<<S<<endl;
    }
    
    int main()
    {
        int i;
        
        cout<<"输入进程个数:"<<endl;
        cin >> n;
        
        cout<<"输入各个进程名字\到达时间,运行时间及优先级:"<<endl;
        
        for(i=0;i<n;i++){
            cin>>pcb[i].name>>pcb[i].daoda>>pcb[i].yunxing>>pcb[i].youxian;
        } 
        cout<<"显示各个进程的参数:"<<endl;
        cout<<"进程名"<<"\t"<<"   到达时间"<<"\t"<<"   运行时间"<<"\t"<<"   优先级"<<endl;
        
        for(i=0;i<n;i++){
            cout<<"Job"<<i+1<<"\t\t"<<pcb[i].daoda<<"\t\t"<<pcb[i].yunxing<<"\t\t"<<pcb[i].youxian<<endl;
        } 
        
        First();
        T = 0;
        S = 0;
    	return 0;
    }
    
    
    • 非抢占式静态优先级
    #include <bits/stdc++.h>
    #include <iostream>
    #include <stdio.h>
    #include <math.h>
    #include <stdlib.h>
    #include <string>
    #include <ctype.h>
    #include <string.h>
    #include <algorithm>
    #include <vector>
    #include <queue>
    #include <set>
    #include <map>
    #include <stack>
    #define maxn 100
    using namespace std;
    
    typedef struct Node{
        char name;
        double daoda;
        double yunxing;
        double youxian;
        double start;
        double end;
        double zhouzhuan;
        double daiquan;
    }PCB;
    PCB pcb[maxn]; 
    
    //平均 
    double T;
    double S;
    int n;//进程数量
    
    
    //根据到达的时间先进行排序一次 
    bool cmp1(Node a,Node b){
    	return a.daoda < b.daoda; 
    }
    //根据优先级进行排序 
    bool cmp2(Node a,Node b){
    	return a.youxian > b.youxian; 
    }
    //非抢占 静态优先级 
    void jingtaiyouxianji()
    {
    	sort(pcb,pcb+n,cmp1);
    	cout<<"===============静态非抢占式优先级调度算法==============="<<endl;
    	//先要执行第一个到达的进程
    	//time为记录的总时间 
    	double time = max(0.0,pcb[0].daoda); 
    	time += pcb[0].yunxing;
    	int cnt = 0;
    	double t = 0,s = 0;
    	for(int i=1;i<n;i++){
    		//判断当前时间是否大于后面的进程的到达时间 
    		if(time > pcb[i].daoda){
    			cnt++;
    		}
    		//根据进程的优先级进行排序 
    		sort(pcb+i,pcb+cnt+i,cmp2);
    		
    		pcb[i].start = time;
            pcb[i].end = time + pcb[i].yunxing;
            pcb[i].zhouzhuan = pcb[i].end - pcb[i].daoda;
            pcb[i].daiquan = pcb[i].zhouzhuan / pcb[i].yunxing;
            
    		//更新一下当前总时间 
    		time += pcb[i].yunxing;
    		
    		//求两个和 
            t += pcb[i].zhouzhuan;
            s += pcb[i].daiquan;      
        }
        
        T = t / n;
        S = s / n;
        cout<<"平均周转时间:"<<T<<endl;
        cout<<"平均带权周转时间:"<<S<<endl;
    	
    }
    int main()
    {
    	int i;
        
        cout<<"输入进程个数:"<<endl;
        cin >> n;
        
        cout<<"输入各个进程名字\到达时间,运行时间及优先级:"<<endl;
        
        for(i=0;i<n;i++){
            cin>>pcb[i].name>>pcb[i].daoda>>pcb[i].yunxing>>pcb[i].youxian;
        } 
        
        cout<<"显示各个进程的参数:"<<endl;
        cout<<"进程名"<<"\t"<<"   到达时间"<<"\t"<<"   运行时间"<<"\t"<<"   优先级"<<endl;
        
        for(i=0;i<n;i++){
            cout<<"Job"<<i+1<<"\t\t"<<pcb[i].daoda<<"\t\t"<<pcb[i].yunxing<<"\t\t"<<pcb[i].youxian<<endl;
        } 
        
        jingtaiyouxianji();
        
    	return 0;
    }
    
    
    展开全文
  • 摘要:本文主要是总结了深度学习中几种常用的优化器,介绍其设计原理,优缺点等。1.什么是优化器?2.有哪些优化器?3.优化算法的选择与使用策略4.参考资料1 什么是优化器?(1)解释一言以蔽之,优化器就是在深度...
  • assertion(断言)在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。在实现中,assertion就是在程序中的一条语句,它对一个boolean表达式进行检查,一个正确程序必须保证这个boolean表达式的值为...
  • 机器人避障相关知识

    万次阅读 多人点赞 2018-04-26 15:07:09
    目录 一、避障概念: 二、避障常用哪些传感器 2.1 超声波 2.2 红外 2.3 激光 2.4 视觉 三、避障常用算法原理 3.1 Bug算法 ...五、算法设计 ...六、多机协同避障策略有哪些? 七、避障有无标准...
  • Emacs 编辑器的使用方法掌握各种常用的键盘操作命令 理解并掌握处理机调度算法 二实验内容及要求 在采用多道系统的设计程序中往往若干进程同时处于就绪状态当就绪状态进程数 大于处理机数时就必须按照某种策略来...
  • 3种常用的缓存读写策略! 系统设计 编码之道(必看 ) RestFul API 简明教程 Java 编程规范以及优雅 Java 代码实践总结 Java 命名之道 常用框架 如果你没有接触过 Java Web 开发的话,可以先看一下我总结的 ...
  • 3种常用的缓存读写策略! 系统设计 编码之道(必看 ) RestFul API 简明教程 Java 编程规范以及优雅 Java 代码实践总结 Java 命名之道 常用框架 如果你没有接触过 Java Web 开发的话,可以先看一下我总结的 ...
  • 3种常用的缓存读写策略! 系统设计 编码之道(必看 ) RestFul API 简明教程 Java 编程规范以及优雅 Java 代码实践总结 Java 命名之道 常用框架 如果你没有接触过 Java Web 开发的话,可以先看一下我总结的 ...
  • 1.2.6 一颗现代处理器,每秒大概可以执行多少条简单MOV指令,有哪些主要影响因素 1.2.7 请分析 MaxCompute 产品与分布式技术关系、当前大数据计算平台类产品市场现状和发展趋势 1.2.8 对大数据平台中...
  • 从Java基础、JavaWeb基础到常用的框架再到面试题都完整的教程,几乎涵盖了Java后端必备的知识点。该开源仓库的文章都是我个人原创,公众号发过的技术文章(干货)也会相关的目录整理,很多知识点我还在不停的...
  • ● 阐释了常用的C抖编程理念和技术。 ● 提供了大量的附注,如提示、警告、注意等。 . 本书的作者和编辑尽最大的努力使本书简单、明了、生动有趣。我们的目标是,读者阅读本书后,能够 编写出可靠、高效的程序,...
  • ● 阐释了常用的C抖编程理念和技术。 ● 提供了大量的附注,如提示、警告、注意等。 . 本书的作者和编辑尽最大的努力使本书简单、明了、生动有趣。我们的目标是,读者阅读本书后,能够 编写出可靠、高效的程序,...
  • ● 阐释了常用的C抖编程理念和技术。 ● 提供了大量的附注,如提示、警告、注意等。 . 本书的作者和编辑尽最大的努力使本书简单、明了、生动有趣。我们的目标是,读者阅读本书后,能够 编写出可靠、高效的程序,...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    通过演示及讲述,讲解课程设计的整体情况,针对其设计提出一些技术及细节问题确认是否真正理解课程设计要点、是否掌握了进行系统设计的知识和能力、是否本人完成。如通发现没有真正设计或者不清楚技术细节,则...
  • 书中分析了海量数据集数据挖掘常用的算法,介绍了目前Web应用的许多重要话题。主要内容包括: 分布式文件系统以及Map-Reduce工具; 相似性搜索; 数据流处理以及针对易丢失数据等特殊情况的专用处理算法; 搜索引擎...
  • 书中分析了海量数据集数据挖掘常用的算法,介绍了目前Web应用的许多重要话题。主要内容包括: 分布式文件系统以及Map-Reduce工具; 相似性搜索; 数据流处理以及针对易丢失数据等特殊情况的专用处理算法; 搜索引擎...
  • Redis 过期策略有哪些?手写一下 LRU 代码实现? 如何保证 Redis 高并发、高可用?Redis 主从复制原理能介绍一下么?Redis 哨兵原理能介绍一下么? Redis 主从架构是怎样? Redis 持久化有哪几种方式?...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

常用的算法设计策略有哪些