精华内容
下载资源
问答
  • 使用simulink建立整车控制策略的基本模型,包括驱动,制动,能量回收等
  • 策略路由 路由策略 双点双向引入

    万次阅读 多人点赞 2020-07-10 01:33:17
    策略路由 路由策略 双点双向引入 一、策略路由 (一)策略路由–Policy-Based Routing—PBR 1、什么是策略路由: 对特定数据报文不按照路由表内的条目执行转发,根据需要按照某种策略改变数据报文转发路径。 2、...

    锲而不舍,金石可镂。

    策略路由 路由策略 双点双向引入

    一、策略路由

    (一)策略路由–Policy-Based Routing—PBR

    1、什么是策略路由:

    对特定数据报文不按照路由表内的条目执行转发,根据需要按照某种策略改变数据报文转发路径。

    2、运行机制:

    根据的报文的目的地址,报文的源地址,报文的大小和链路质量等属性制定策略路由,改变报文的转发路径。手动配置后基于策略转发,失败后再查找路由表转发。

    3、实现方式:

    华为设备支持3种策略路由:

    本地策略路由

    (1)名称:本地策略路由
    (2)对象:本设备产生流量
    (3)应用:对本机的ICMP,BGP等各种报文需要使用不同的源地址或者不同长度的报文通过不通方式进行发送时。

    接口策略路由

    (1)名称:接口策略路由
    (2)对象:流经本设备的数据
    (3)应用:针对用户不同源目地的数据按照流重定向选择下一跳,不按照路由表转发。

    智能策略路由(SSR)

    (1)名称:智能策略路由
    (2)对象:流经本设备的数据,基于链路质量信息为业务数据流选择最佳链路。
    (3)应用:对用户不同业务选择不同质量的链路。
    (4)注意:SSR的功能需要配合License来使用。

    (二)本地策略路由

    1、配置本地策略路由的匹配规则:

    可以通过ACL匹配到数据或者报文长度来进行对需要策略的数据执行匹配。

    2、配置本地策略路由的转发动作:

    可以通过接口或者下一跳地址发出。

    3、本地应用本地策略路由:

    在系统视图ip lcal policy-based-route X-X-----------调用名称为x-x的本地策略路由。

    (三)接口策略路由

    1、通过ACL匹配需要策略的流量

    2、定义流分类

    需要执行流策略的流量–即哪些流量需要转发
    通过ACL匹配需要策略的流量

    3、制定流行为

    指定需要执行流策略的动作,即如何转发

    4、制定流策略

    将流分类(匹配到需要转发的流量)和流行为(具体需要转发的动作)关联起来

    5、挂接流策略

    接口下在数据的进方向挂接流策略

    策略路由----PBR Policy Based Route—基于策略的路由(选址转发)

    策略路由----针对数据---------接口

    (四)策略路由配置

    1、策略路由指定的出接口要优于指定的下一跳
    2、策略路由指定的下一跳>路由表>策略部署的默认下一跳。

    二、路由策略

    路由策略----RP Route policy

    路由策略-------针对路由条目----路由协议----route policy
    人为的控制或者影响路由协议选路----过滤,cost,引入

    路由三要素----前缀----掩码----下一跳
    动态三要素----前缀----掩码----cost

    路由策略----路由条目

    对象:路由条目
    策略:过滤;修改路由属性

    1、路由匹配工具----抓取路由

    同意路由匹配工具

    ① ACL
    ② IP-preix----前缀列表
    ③ route-policy

    2、 BGP专属路由匹配工具

    ① ip murit-fiete----团体属性过滤列表
    ② ip as-patch-fiter----as路 径属性过滤列表

    3、路由策略工具----执行路由动作

    过滤

    ① route-policy
    ② fiter-policy

    属性修改

    route-policy

    2.1 前缀列表

    注意:由于route-policy不支持匹配Loopback接口,使用前缀列表来匹配loopbackO接口的路由。

    greater-equal X 掩码大约等于X
    less-equal X 掩码小于等于X

    如果只写前缀长度,掩码长度等于前缀长度
    如果只写greater-equal X,会自动补全less-equal 32

    在Route- policy同时调用ACL和ip-prix时,谁最后调用启用谁(ACL与ip-prix是覆盖关系)

    1、匹配任意掩码的路-------0.0.0.0 0 greater-equal x less-equal X
    2、匹配默认路----------------0.0.0.0 0 greater-equal 0 less-equal 0
    3、匹配所以明细路由-------0.0.0.0 0 greater-equal 1
    4、匹配所有的主机路-------0.0.0.0 0 greater-equal 32

    三、拓扑

    在这里插入图片描述

    四、策略配置

    AR-1的环回口loopback1 1.1.1.1/32模拟外部路由

    [AR-1]acl 2010
    [AR-1-acl-basic-2010] rule 5 permit source 1.1.1.1 0
    [AR-1-acl-basic-2010]rule 10 permit source 1.1.1.2 0
    
    [AR-1]route-policy di permit  node 10
    [AR-1-route-policy]if-match acl 2010
    
    [AR-1]ospf 
    [AR-1-ospf-1]import-route direct type 1 route-policy di
    

    4.1 网络互通

    在边界路由器完成双点双向路由引入实现全网互通与冗余备份

    [AR-3]isis 
    [AR-3-isis-1]network-entity 49.0001.0000.0000.0003.00
    [AR-3-isis-1]cost-style wide
    [AR-3-isis-1]quit
    [AR-3]int g0/0/0
    [AR-3-GigabitEthernet0/0/0]isis enable 
    [AR-3-GigabitEthernet0/0/0]int l0
    [AR-3-LoopBack0]isis enable 
    [AR-3-LoopBack0]quit
    [AR-3]ospf 1 router-id 3.3.3.3
    [AR-3-ospf-1]a 0   
    [AR-3-ospf-1-area-0.0.0.0]net 23.1.1.3 0.0.0.0、
    
    [AR-3]ospf 1	
    [AR-3-ospf-1]import-route isis
    [AR-3-ospf-1]isis 	
    [AR-3-isis-1]import-route ospf
    

    dis ip routing-table
    在这里插入图片描述

    4.2 网络优化

    通过路由策略消除存在次优路径与环路问题
    AR4:正常双向引入即可

    [AR-3]isis
    [AR-3-isis-1]undo import-route ospf
    [AR-3-isis-1]ospf 
    [AR-3-ospf-1]undo import-route  isis
    [AR-3-ospf-1]quit
    [AR-3]ospf 
    [AR-3-ospf-1]import-route  isis
    [AR-3-ospf-1]quit
    [AR-3]isis
    [AR-3-isis-1]import-route ospf
    [AR-3-isis-1]quit
    

    次优路径

    tracert 1.1.1.1
    在这里插入图片描述

    [AR-3]ospf 
    [AR-3-ospf-1]import-route  isis 1 type 1
    

    环路

    tracert 1.1.1.1
    在这里插入图片描述
    消除环路

    [AR-4]ip ip-prefix ospf index 10 permit 1.1.1.1 32
    [AR-4]ip ip-prefix ospf index 20 permit 2.2.2.2 32
    [AR-4]ip ip-prefix ospf index 30 permit 3.3.3.3 32
    [AR-4]ip ip-prefix ospf index 40 permit 4.4.4.4 32
    [AR-4]ip ip-prefix ospf index 50 permit 1.1.1.2 32
    
    [AR-4]route-policy ospf-->isis permit node 20
    [AR-4-route-policy]if-match  ip-prefix ospf
    [AR-4-route-policy]apply tag 100
    [AR-4-route-policy]quit
    [AR-4]isis	
    [AR-4-isis-1]import-route ospf 1 route-policy  ospf-->isis 
    [AR-4-isis-1]quit
    
    [AR-3]route-policy isis-->ospf deny node 10 //创建名称为isis-->ospf的路由策略组,此组的节点10执行拒绝路由的过滤动作
    [AR-3-route-policy]if-match tag 100         //此节点过滤带有100 tag标记的路由
    [AR-3-route-policy]quit
    [AR-3]route-policy isis-->ospf permit node 20
    
    [AR-3]ospf
    [AR-3-ospf-1]import-route isis route-policy  isis-->ospf  type 1 
    //在ospf进程中将isis进程1的路由导入,进入OSPF的IS-IS路由需要经过名称为isis-->ospf 的策略过滤 
    

    tracert 1.1.1.1
    在这里插入图片描述
    tracert 1.1.1.1
    在这里插入图片描述

    [AR-3]ip ip-prefix ospf index 10 permit 1.1.1.1 32
    [AR-3]ip ip-prefix ospf index 20 permit 2.2.2.2 32
    [AR-3]ip ip-prefix ospf index 30 permit 3.3.3.3 32
    [AR-3]ip ip-prefix ospf index 40 permit 4.4.4.4 32
    [AR-3]ip ip-prefix ospf index 50 permit 1.1.1.2 32
    
    [AR-3]route-policy ospf-->isis permit node 20
    [AR-3-route-policy]if-match ip-prefix ospf
    [AR-3-route-policy]apply  tag 200
    [AR-3-route-policy]isis
    [AR-3-isis-1]import-route ospf 1 route-policy  ospf-->isis 
    
    [AR-4]route-policy isis-->ospf deny node 8
    [AR-4-route-policy]if-match tag  200
    [AR-4-route-policy]quit
    [AR-4]route-policy isis-->ospf permit node 20
    
    [AR-4-ospf-1]import-route  isis route-policy  isis-->ospf  type 1
    

    tracert 1.1.1.1
    在这里插入图片描述
    tracert 1.1.1.1
    在这里插入图片描述

    [AR-4]route-policy isis-->ospf  permit node 15
    [AR-4-route-policy]apply tag 300
    [AR-4-route-policy]quit
    
    [AR-4]route-policy ospf-->isis  deny node 8
    [AR-4-route-policy]if-match  tag  400
    
    [AR-3]route-policy ospf-->isis  deny node 8
    [AR-3-route-policy]if-match tag  300
    [AR-3-route-policy]quit
    
    [AR-3]route-policy isis-->ospf  permit node 20
    [AR-3-route-policy]apply  tag 400
    

    消除次优

    [AR-4]route-policy isis-->pre permit node 20
    [AR-4-route-policy]if-match  tag  200
    [AR-4-route-policy]apply preference 151
    [AR-4-route-policy]quit
    [AR-4]isis
    [AR-4-isis-1]preference route-policy isis-->pre 15
    
    [AR-3]route-policy isis-->pre permit node 10
    [AR-3-route-policy]if-match tag  100
    [AR-3-route-policy]apply preference 151
    [AR-3-route-policy]isis 	
    [AR-3-isis-1]preference  route-policy  isis-->pre 15
    

    tracert 1.1.1.1
    在这里插入图片描述

    4.3 网络控制

    网络控制(不要修改接口开销)

    ① 修改开销(引入)
    ② 修改优先级(注意匹配策略)
    ③ 修改下一跳权值
    ④ 静态
    ⑤ 过滤

    (1)OSPF网络(AR-4除外)去往6.6.6.1的数据走上行线路:R3---->R5---->R6

    修改开销

    [AR-4]ip ip-prefix 35 permit  35.1.1.0 24
    [AR-4]ip ip-prefix 35 permit  6.6.6.1 32
    
    [AR-4]route-policy isis-->ospf permit  node 14
    [AR-4-route-policy]if-match ip-prefix 35 
    [AR-4-route-policy] apply cost 20 
    [AR-4-route-policy] apply tag 200
    

    在这里插入图片描述
    (2)OSPF网络(AR-3除外)去往6.6.6.2的数据走下行线路:R4---->R5---->R6

    修改优先级

    [AR-2]ip ip-prefix 23 permit 23.1.1.3 32
    [AR-2]ip ip-prefix 62 permit 6.6.6.2 32
    
    [AR-2]route-policy pre permit node 10
    [AR-2-route-policy]if-match ip-prefix 62
    [AR-2-route-policy]if-match  ip next-hop  ip-prefix 23
    [AR-2-route-policy]apply  preference 130
    [AR-2-route-policy]quit
    
    [AR-2]ospf	
    [AR-2-ospf-1]preference ase route-policy  pre
    

    dis ip routing-table
    在这里插入图片描述
    (3)IS-IS网络(AR-3除外)去往1.1.1.2的数据走下行线路: R4---->R2---->R1

    在AR-3上配置:增加1.1.1.2的开销值

    [AR-3]ip ip-prefix 452 permit 1.1.1.2 32
    [AR-3]route-policy ospf-->isis permit node 16
    	
    [AR-3-route-policy]if-match ip-prefix 452
    [AR-3-route-policy]apply tag 100
    [AR-3-route-policy]apply cost 200
    [AR-3-route-policy]quit
    
    [AR-3]route-policy ospf-->isis  permit  node 22
    [AR-3-route-policy]apply tag 100
    

    dis ip routing-table
    在这里插入图片描述
    (4)IS-IS网络(AR-4除外)去往1.1.1.1的数据走上行线路: R3---->R2---->R1

    策略路由----指定数据转发----不查看路由表

    ① 匹配数据
    acl

    ② 制定流分类
    traffic classifier

    ③ 制定流行为
    traffic behavior

    ④ 策略的组合
    traffic policy 数据与策略的组合

    ⑤ 挂接流策略
    在数据的进站方向挂接

    用策略路由写

    [AR-5]acl 3010
    [AR-5-acl-adv-3010]rule 10 permit ip source any destination 1.1.1.1 0  //匹配内网去往1.1.1.1的流量
    [AR-5-acl-adv-3010]quit
     
    [AR-5]traffic classifier host           //创建名称为host的流分类(这里匹配的到的数据将执行流动作)
    [AR-5-classifier-host]if-match acl 3010 //通过acl3010获得流量需要执行流分类	
    [AR-5-classifier-host]quit
    
    [AR-5]traffic behavior host                       //创建名称为host的流行为
    [AR-5-behavior-host]redirect ip-nexthop 35.1.1.3  //这个流行为匹配到的流量执行下一跳重定向动作
    [AR-5-behavior-host]quit
    
    [AR-5]traffic policy host                              //创建名称为host的流策略
    [AR-5-trafficpolicy-host]classifier host behavior host //将名称为host流分类匹配到数据和名称为host的流行为结合
    [AR-5-trafficpolicy-host]quit
    
    [AR-5]int g0/0/2  
    [AR-5-GigabitEthernet0/0/2]traffic-policy host  inbound
    //将名称为cl的流策略挂接到此接口的入方向,进入此接口被匹配到数据将安装流策略的规定动作转发,没有匹配到数据按照路由表正常转发
    

    策略优先级高于路由表优先级

    tracert 1.1.1.1
    在这里插入图片描述

    在这里插入图片描述

    本人所有文章都受版权保护,著作权归艺博东所有!未经授权,转载必究或附上其原创链接。

    展开全文
  • 阿尔法策略与贝塔策略

    千次阅读 2020-05-11 14:50:15
    阿尔法策略: 主动型策略、主动收益(阿尔法收益)、精选高品质个股、争取实现超越大盘收益、适合激进投资者、对选股和择时能力要求极高、大盘在牛市中表现强势、大盘在熊市中回落幅度比贝塔策略更大、牛市有优势、 ...

    阿尔法策略:
    主动型策略、主动收益(阿尔法收益)、精选高品质个股、争取实现超越大盘收益、适合激进投资者、对选股和择时能力要求极高、大盘在牛市中表现强势、大盘在熊市中回落幅度比贝塔策略更大、牛市有优势、


    贝塔策略:
    被动型策略、被动收益(贝塔收益)、被动选择指数、实现对大盘指数的精准跟踪、适合稳健投资者、对择时能力要求极高、大盘在熊市中更加抗跌、大盘在牛市中比阿尔法策略涨幅偏小、


    1

    阿尔法策略,是一种主动型投资策略,主要依靠精选行业和个股来超越大盘。而阿尔法策略追求的就是阿尔法收益,指投资收益中超出市场收益的部分。激进投资者适合阿尔法策略,尤其在市场上涨阶段会有优势。

    纯粹阿尔法策略在成熟的市场是一类种常用且成功的投资策略,如全球最大的对冲基金桥水公司的PureAlpha。纯粹阿尔法策略要通过卖空指数剥离出纯粹的阿尔法收益,对操作能力和资金门槛要求较高,同时稳定性也较高。而在国内市场的阿尔法策略,通常不是纯粹阿尔法策略,因为稳定性相对较差。由于受到行业轮动显著及对冲受限的市场的影响,投资者在使用阿尔法策略时,其收益充满变数,很多时候包含了贝塔收益。

    贝塔策略,是一种被动型投资策略,主要依靠把握市场大势来获得超越大盘的收益。贝塔策略追求的是市场收益,也就是贝塔收益。稳健的投资者适合贝塔策略。

    由于国内市场已经有了众多跟踪不同市场指数的金融投资产品,使得贝塔策略广泛覆盖;继而,在中国市场牛短熊长的环境下,如果不主动择时操作,贝塔策略很容易出现负收益。在经济调结构的转型期间,预期的不确定性会导致市场波动加大,从而增加了贝塔策略的投资风险。中国股市牛短熊长,所以很容易出现负收益。

    阿尔法策略与贝塔策略是两类基于不同的出发点和侧重点来获取超越大盘表现的投资策略,市场中性策略则介于二者之间。一言以蔽之,基金投资的阿尔法策略就是选择那些善于自下而上发掘个股、轻选时重选股型基金经理所管理的基金,而贝塔策略则是依靠那些长于自上而下宏观判断、轻选股重选时型基金经理所管理的基金。由于出发点和侧重点有别,二者在资产配置、行业轮动、个股周期等方面都相去甚远,进而在牛熊殊异的行情下各有千秋。那么,作为基金投资者,究竟是选择阿尔法选手管理的基金,或是贝塔选手管理的基金,还是选择中性策略管理的基金呢?

    “时进则进”的阿尔法策略。例如2009年,沪深300指数从年初的1817.72点攀升至年底的3575.68点,涨幅高达96.71%。中国银河证券研究所《中国证券投资基金2009年业绩统计报告》研究结果表明,在主动管理的股票型基金中,银华优选、新华成长、兴业社会分列状元、榜眼、探花之位,收益实现翻番。进一步分析上述三只基金季报,全年股票仓位波动范围不大,基金经理主要通过精选行业个股战胜沪深300指数涨幅。反观那些2008年的贝塔明星,基于投资理念上或多或少想做绝对收益,在市场上涨时,因为心态谨慎,加仓迟缓,分散持股而集体失语,牵制了诸多基金的表现。事后想来,在2009年以来的这波牛市行情中,信心确实要比黄金和货币还要重要,该动则动,动如脱兔,飞蓬遇飘风而致千里,是乘势而为。

    “时退则退”的贝塔策略。例如2008年,沪深300指数从年初的5338.27点暴跌至年底的1817.72点,跌幅深达-65.95%。通过中国银河证券研究所《中国证券投资基金2008年业绩统计报告》同样可以看出,在主动管理的混合型基金中,泰达成长、华夏大盘、金鹰小盘等由于对贝塔的高度关注,对风险的严格控制,对仓位的小心谨慎,尽管没有实现绝对收益,但几近跑赢沪深300指数50%。对比那些基金界的“四大恶人”,熊市阶段不做贝塔,不降低仓位,覆巢之下安有完卵?风险管理成了2008年基金投资管理的核心,因此一役而跌得比别人少成就了贝塔基金经理显赫的名声。他们信奉好的投资者在衡量风险和挖掘机会上必须分配同样多时间,放弃风险的管制就是放任收益的流逝,该静则静,静如处子,伏蛰临岁寒而息百日,是藏地而眠。

    “动静不失其时”的中性策略。例如,纵观2008、2009两年以来的熊牛转换,既能在下跌阶段坚决实施贝塔策略来成功规避暴跌,又能在上涨阶段通过阿尔法策略来获取超额收益的基金犹如凤毛麟角。大多数上涨时能精选行业个股的阿尔法选手,涨势凌厉却疏于风险管理;而大多数下跌时能控制下行风险的贝塔选手,风格上又稳健有余进取不足。正所谓千金易买,一将难求!对基金投资者来说,激进型的可以关注阿尔法做得好的基金经理,在上涨阶段有优势;稳健型的可以关注组合贝塔值控制得好的基金经理,在下跌阶段能从容。对那些集激进与稳健于一身的“双面胶”投资者,要想取得能守善攻的投资绩效,除了遇到阿尔法策略和贝塔策略攻防转换灵活的基金经理之外,就得靠自己“动静不失其时”地运用中性策略,双手互搏,“射幸数跌,不如审发;日出而作,日落而息”和谐投资了。


    2

    投资者经常会有这样的想法:好股票总会涨的,所以会拿着貌似不错的股票焦虑地等待上涨;也常有这样的想法:最近大盘不错,我该拿点什么票,多少可以赚一些。其实不论我们有怎样的想法,最后总可以归入两类投资策略中的一类,其中一类属于主动性投资,而另一类属于被动性投资。在理论上前者被称为阿尔法策略而后者被称为贝塔策略,尽管这两种策略只是在一些高级投资论坛上被经常提到,但实际上每个投资者哪怕是最普通的投资者也在不知不觉中使用这两种策略或其中的一种。

    投资者经常会有这样的想法:好股票总会涨的,所以会拿着貌似不错的股票焦虑地等待上涨;也常有这样的想法:最近大盘不错,我该拿点什么票,多少可以赚一些。其实不论我们有怎样的想法,最后总可以归入两类投资策略中的一类,其中一类属于主动性投资,而另一类属于被动性投资。在理论上前者被称为阿尔法策略而后者被称为贝塔策略,尽管这两种策略只是在一些高级投资论坛上被经常提到,但实际上每个投资者哪怕是最普通的投资者也在不知不觉中使用这两种策略或其中的一种。

    单纯的阿尔法策略以选择个股为主,只要个股估值有足够的吸引力,或者成长性诱人,那么投资者就可以主动出击。由于回避了研判市要配套相应的做空机制,这样就可以减少净值的波动,不过国内在阿尔法策略运用中对于做空机制比较藐视。至于贝塔策略则主要聚焦于市场的趋势,一旦判断上涨趋势形成则跟随市场建仓。由于这种投资行为是由市场趋势决定的,所以属于被动性投资。一般来说我们在实际投资中不会采用单一的阿尔法策略或贝塔策略,可能会将资金分成两部分,分别采用阿尔法策略和贝塔策略。也就是拿一些中长线筹码,当然也包括无奈被深套的筹码,同时用另一些资金参与趋势性行情。也可能在不同的时段采用不同的策略,市场不好的时候拿着筹码死捂,市场大涨时跟着趋势跑。

    本栏主要跟踪上证指数的周线波段趋势,因此属于被动性的贝塔策略,甚至在被动跟随上证指数建仓的时候忽略个股而直奔行业,通过相应的ETF基金或分级基金参与。如果我们对于个股有独到研究,或者对于个股的资产重组有可靠的信息来源,

    场涨跌这个难题,所以阿尔法策略更适合对于市场波动茫然的投资者。当然真正的阿尔法策略还需或者对于某一行业的变化十分敏感,那么采用阿尔法策略无疑更合适。

    从更广泛的意义上说,阿尔法策略也并非一定是一家具体的上市公司。比如投资“一带一路”板块,就是一个广义的阿尔法策略。尽管这是一个板块,但因为持续向好,所以我们可以在不考虑市场波动的情况下进行主动性投资,这也是阿尔法策略的本质。上周一带一路指数(399991)上涨1.72%,CSSW丝路指数(000853)上涨1.42%,而同期上证指数则翻绿。这两个指数所对应的分级基金B份额则表现更佳,其中一带一B(502015)周涨幅为16.12%,一带一B(150276)为8.37%,表明在贝塔策略的前提下兼顾阿尔法策略可以获取更高的收益。如果把工作做得更细一些,实际上我们也还是可以从板块中选择个股的,比如在“一带一路”板块中选择更为强势的个股。

    看上去贝塔策略叠加阿尔法策略更好,那么反过来也是一样的,就是在阿尔法策略的基础上再结合贝塔策略选择合适的建仓时机。不过这两个策略要做到始终一致也是不可能的,只是建仓的买点可以尽量凑合在一起。比如看好一个个股,然后在市场形成上涨趋势时建仓,这样至少可以在拿到筹码之后尽快脱离成本区,我们知道保持账面的盈余对于持筹的信心会很有很大提升。

    从周线趋势的演变看,目前显然已经过了建仓期,也就是说已经过了贝塔策略中的买点,但阿尔法策略仍然是有效的,只要能够找到好的个股并且愿意承受较长时间的寂寞。而对于贝塔策略来说,尽管现在仍然处于持仓的阶段但也同样需要耐心和毅力,因为已经开始面临日线调整趋势的压力。

    在一轮日线调整中至少会出现一次较为像样的下跌,而现在只有上周五上证指数的一根小阴线。接下来预期会有两种选择,一种是本周一立马开杀,直接下到日线调整的低点。还有一种就是周初强势震荡然后逐步回落并探明日线调整的低点。不论怎么变,对于贝塔策略来说都是拿着筹码不为所动,耐心等待。

    推荐阅读:

    1.一个量化策略师的自白(好文强烈推荐)

    2.股票期货经典的量化交易策略都在这里了!(源码)

    3.期货/股票数据大全查询(历史/实时/Tick/财务等)

    4.三分钟弄明白为什么贝叶斯是量化工作者最常用的工具

    5.学习Python有哪些书籍?这里有一份书单送给你

    6.江湖中常说的“网格交易法”到底是什么?

    7.10种经典的日内交易策略模型思路

    8.干货 | 量化选股策略模型大全

    9.量化金融经典理论、重要模型、发展简史大全

    展开全文
  • java策略模式

    千次阅读 2019-04-09 18:19:48
    在说策略模式之前,先看一个小例子: 假如:有一场演讲比赛,有十个评委对参赛选手的成绩进行打分,但最终要通过评委的平均分来决定选手的名次。现在有两种求平均分的策略: 第一种:将十名裁判的分加起来求平均值...

    示例:

    在说策略模式之前,先看一个小例子:
    假如:有一场演讲比赛,有十个评委对参赛选手的成绩进行打分,但最终要通过评委的平均分来决定选手的名次。现在有两种求平均分的策略:
    第一种:将十名裁判的分加起来求平均值。
    第二种:去掉最高分和最低分后求平均值。
    面对以上的需求,我们可能会写出如下代码:

    public class Averge {
    
        /**
         * @param a  每个裁判所打的分数
         * @param strategy 使用的策略
         * @return
         */
        public double getScore(double a[],String strategy){
    
            double score =0,sum = 0;
    
            //使用第一种策略打分
            if("策略一".equals(strategy)){
                System.out.println("使用策略1计算分数!");
                for (int i = 0; i < a.length; i++) {
                    sum = sum + a[i];
                }
                score = sum/a.length;
    
                return score;           //返回平均值
    
            //使用第二种策略打分
            }else{
                System.out.println("使用策略2计算分数!");
                Arrays.sort(a);
                for (int i = 1; i < a.length - 1; i++) {
                    sum = sum + a[i];
                }
                score = sum/(a.length - 2);
    
                return score;
            }
        }
    }
    

    以上代码工作的很好,完全没有问题。但是,上面的代码存在一些问题,比如:将所有的策略都放在了一个方法里面,显得方法非常臃肿(这里代码少可能看不出来)。此时开始修改代码,将每一种策略进行提取出来封装为方法method1,method2,然后在if else分支进行调用方法即可。代码如下:

    public class Averge {
    
        /**
         * @param a  每个裁判所打的分数
         * @param strategy 使用的策略
         * @return
         */
        public double getScore(double a[],String strategy){
    
            //使用第一种策略打分
            if("策略一".equals(strategy)){
    
                System.out.println("使用策略1计算分数!");
                return method1(a);
            //使用第二种策略打分
            }else{
    
                System.out.println("使用策略2计算分数!");
                return method2(a);
            }
        }
    
        public double method1(double a[]){
    
            double score =0,sum = 0;
            for (int i = 0; i < a.length; i++) {
                sum = sum + a[i];
            }
            score = sum/a.length;
            return score;
        }
    
        public double method2(double a[]){
    
            double score =0,sum = 0;
            Arrays.sort(a);
            for (int i = 1; i < a.length - 1; i++) {
                sum = sum + a[i];
            }
            score = sum/(a.length - 2);
            return score;
        }
    }
    
    

    经过如上的改造,我们的方法显得不是那么的臃肿,但是,如果说此时我们又要扩展一种计算平均分的策略呢(比如:增加一种只去掉最高分然后求平均分的打分策略)?
    此时我们首先需要在该类中增加一个求平均值的方法method3,然后编写方法实现,然后再增加 if–else 语句块。这样显得十分的麻烦,而且这样的设计也违背了设计原则之一的----开闭原则。

    开闭原则:

    对于扩展是开放的(Open for extension)。这意味着模块的行为是可以扩展的。当应用的需求改变时,我们可以对模块进行扩展,使其具有满足那些改变的新行为。也就是说,我们可以改变模块的功能。

    对于修改是关闭的(Closed for modification)。对模块行为进行扩展时,不必改动模块的源代码或者二进制代码。

    以上的代码设计,不易扩展并且不易维护。所以我们需要一些解决办法来将我们的代码符合开闭原则,并且易扩展和维护。所以我们开始使用策略模式来解决我们的问题。

    定义:

    策略模式定义了一系列的算法,把他们一个个封装起来,并且使他们可相互替换。该模式使得算法可独立于使用它的客户端而变化。

    结构:

    策略模式结构中包含了三种角色:1.策略 2.上下文 3.具体策略

    1. 策略:策略是一个接口,该接口定义若干算法标识,即定义了若干个抽象方法。
    2. 上下文(context):上下文是依赖接口的类(是面向策略二设计的类),即上下文中包含了策略变量。上下文中提供一个方法,该方法委托策略变量调用具体策略所实现的策略接口中的方法。
    3. 具体策略:具体策略是实现策略接口的类。具体策略实现策略接口所定义的抽象方法。
      以上的打分示例中,method1和method2就相当于一个个具体的策略!

    使用策略模式

    使用策略模式实现评委打分方法:
    1.策略接口:

    public interface Strategy {
        public double getAverge(double a[]);
    }
    

    2.具体策略实现:
    a). 策略A:直接求平均分

    public class StrategyA implements Strategy {
    
       @Override
       public double getAverge(double[] a) {
           
           double score =0,sum = 0;
           for (int i = 0; i < a.length; i++) {
               sum = sum + a[i];
           }
           score = sum/a.length;
           return score;
       }
    }
    

    b). 策略B:去掉最高分和最低分后求平均分

    public class StrategyB implements Strategy{
    
        @Override
        public double getAverge(double[] a) {
    
            double score =0,sum = 0;
            Arrays.sort(a);
            for (int i = 1; i < a.length - 1; i++) {
                sum = sum + a[i];
            }
            score = sum/(a.length - 2);
            return score;
        }
    }
    

    3.策略上下文

    /**
     * 策略上下文
     */
    public class StrategyContext {
    
        //策略变量的引用
        private Strategy strategy;
    
        public void setStrategy(Strategy strategy){
            this.strategy = strategy;
        }
    
        public double getAverge(double a[]){
            if(strategy != null){
                //调用引用策略的方法
                double averge = strategy.getAverge(a);
    
                return averge;
            }else {
                System.out.println("没有求平均值的策略!");
                return -1;
            }
        }
    }
    

    4.客户端

    public class Client {
    
        public static void main(String[] args) {
    
            //模拟评委打分
            double a[] = {1,6,8,4,5,7,4,7,8,9};
    
            //1.创建具体打分策略
            StrategyA strategyA = new StrategyA();
    
            //2.在创建策略上下文的同时,将具体的策略实现对象注入到策略上下文当中
            StrategyContext strategyContext = new StrategyContext(strategyA);
    
            //3.调用上下文对象的方法来完成对具体策略实现的回调
            double averge = strategyContext.getAverge(a);
            System.out.println("策略1:平均分:" + averge );
    
            //======================================================================
    
            //使用第二种求平均分的策略:
            StrategyB strategyB = new StrategyB();
            strategyContext.setStrategy(strategyB);
    
            //调用上下文对象的方法来完成对具体策略实现的回调
            averge = strategyContext.getAverge(a);
            System.out.println("策略2:平均分:" + averge );
    
        }
    }
    

    以上就是策略模式的简单例子实现。在以上示例中我们需要在客户端手动的设置选择哪个策略模式进行打分,其实我们也可以不用手动设置使用哪一个策略,直接在上下文中创建要优先使用的策略,若优先使用的策略执行失败,则进行另一个策略的使用,这样便不需要客户进行手动的设置要使用的策略模式了。示例代码如下:

    public class StrategyContext {
    
        //策略变量的引用
        private Strategy strategy;
    
        public double getAverge(double a[]){
            strategy = new StrategyA();
            try{
                //调用引用策略的方法
                double averge = strategy.getAverge(a);
                return averge;
            }catch (Exception e){
                //策略A失败
                strategy = new StrategyB();
                double averge = strategy.getAverge(a);
                return averge;
            }
        }
    }
    

    深入理解策略模式:

    **策略模式的作用:**就是把具体的算法实现从业务逻辑中剥离出来,成为一系列独立算法类,使得它们可以相互替换。

    **策略模式的着重点:**不是如何来实现算法,而是如何组织和调用这些算法,从而让我们的程序结构更加的灵活、可扩展。

    **策略和上下文的关系:**在策略模式中,一般情况下都是上下文持有策略的引用,以进行对具体策略的调用。但具体的策略对象也可以从上下文中获取所需数据,可以将上下文当做参数传入到具体策略中,具体策略通过回调上下文中的方法来获取其所需要的数据。

    这里关于在策略中回调上下文中的方法示例,引用一个比较好的例子:
    引用连接:https://www.cnblogs.com/lewis0077/p/5133812.html

    在跨国公司中,一般都会在各个国家和地区设置分支机构,聘用当地人为员工,这样就有这样一个需要:每月发工资的时候,中国国籍的员工要发人民币,美国国籍的员工要发美元,英国国籍的要发英镑。

    1 //支付策略接口

    public interface PayStrategy {
         //在支付策略接口的支付方法中含有支付上下文作为参数,以便在具体的支付策略中回调上下文中的方法获取数据
       public void pay(PayContext ctx);
     }
    
    //人民币支付策略
    public class RMBPay implements PayStrategy {
        @Override
        public void pay(PayContext ctx) {
            System.out.println("现在给:"+ctx.getUsername()+" 人民币支付 "+ctx.getMoney()+"元!");
        }
    }
    
    //美金支付策略
    public class DollarPay implements PayStrategy {
        @Override
        public void pay(PayContext ctx) {
            System.out.println("现在给:"+ctx.getUsername()+" 美金支付 "+ctx.getMoney()+"dollar !");
        }
    }
    
    //支付上下文,含有多个算法的公有数据
    public class PayContext {
       //员工姓名
       private String username;
       //员工的工资
       private double money;
       //支付策略
       private PayStrategy payStrategy;
    
       public void pay(){
           //调用具体的支付策略来进行支付
           payStrategy.pay(this);
       }
    
       public PayContext(String username, double money, PayStrategy payStrategy) {
           this.username = username;
           this.money = money;
           this.payStrategy = payStrategy;
       }
    
       public String getUsername() {	
           return username;
       }
    
       public double getMoney() {
           return money;
       }
    }
    
    //外部客户端
    public class Client {
        public static void main(String[] args) {
            //创建具体的支付策略
            PayStrategy rmbStrategy = new RMBPay();
            PayStrategy dollarStrategy = new DollarPay();
            //准备小王的支付上下文
            PayContext ctx = new PayContext("小王",30000,rmbStrategy);
            //向小王支付工资
            ctx.pay();
    
            //准备Jack的支付上下文
            ctx = new PayContext("jack",10000,dollarStrategy);
            //向Jack支付工资
            ctx.pay();
        }
    }
    

    控制台输出:

    现在给:小王 人民币支付 30000.0元!
    现在给:jack 美金支付 10000.0dollar !

    那现在我们要新增一个银行账户的支付策略,该怎么办呢?

    显然我们应该新增一个支付找银行账户的策略实现,由于需要从上下文中获取数据,为了不修改已有的上下文,我们可以通过继承已有的上下文来扩展一个新的带有银行账户的上下文,然后再客户端中使用新的策略实现和带有银行账户的上下文,这样之前已有的实现完全不需要改动,遵守了开闭原则。

    //银行账户支付
    public class AccountPay implements PayStrategy {
        @Override
        public void pay(PayContext ctx) {
            PayContextWithAccount ctxAccount = (PayContextWithAccount) ctx;
            System.out.println("现在给:"+ctxAccount.getUsername()+"的账户:"+ctxAccount.getAccount()+" 支付工资:"+ctxAccount.getMoney()+" 元!");
        }
    }
    
    //带银行账户的支付上下文
    public class PayContextWithAccount extends PayContext {
        //银行账户
        private String account;
        public PayContextWithAccount(String username, double money, PayStrategy payStrategy,String account) {
            super(username, money, payStrategy);
            this.account = account;
        }
    
        public String getAccount() {
            return account;
        }
    }
    
    //外部客户端
    public class Client {
        public static void main(String[] args) {
            //创建具体的支付策略
            PayStrategy rmbStrategy = new RMBPay();
            PayStrategy dollarStrategy = new DollarPay();
            //准备小王的支付上下文
            PayContext ctx = new PayContext("小王",30000,rmbStrategy);
            //向小王支付工资
            ctx.pay();
            //准备Jack的支付上下文
            ctx = new PayContext("jack",10000,dollarStrategy);
            //向Jack支付工资
            ctx.pay();
            //创建支付到银行账户的支付策略
            PayStrategy accountStrategy = new AccountPay();
            //准备带有银行账户的上下文
            ctx = new PayContextWithAccount("小张",40000,accountStrategy,"1234567890");
            //向小张的账户支付
            ctx.pay();
        }
    }
    

    控制台输出:

    现在给:小王 人民币支付 30000.0元!
    现在给:jack 美金支付 10000.0dollar !
    现在给:小张的账户:1234567890 支付工资:40000.0 元!

    除了上面的方法,还有其他的实现方式吗?

    当然有了,上面的实现方式是策略实现所需要的数据都是从上下文中获取,因此扩展了上下文;现在我们可以不扩展上下文,直接从策略实现内部来获取数据,看下面的实现:

    //支付到银行账户的策略
    public class AccountPay2 implements PayStrategy {
        //银行账户
        private String account;
        public AccountPay2(String account) {
            this.account = account;
        }
        @Override
        public void pay(PayContext ctx) {
            System.out.println("现在给:"+ctx.getUsername()+"的账户:"+getAccount()+" 支付工资:"+ctx.getMoney()+" 元!");
        }
        public String getAccount() {
            return account;
        }
        public void setAccount(String account) {
            this.account = account;
        }
    }
    
    //外部客户端
    public class Client {
        public static void main(String[] args) {
            //创建具体的支付策略
            PayStrategy rmbStrategy = new RMBPay();
            PayStrategy dollarStrategy = new DollarPay();
            //准备小王的支付上下文
            PayContext ctx = new PayContext("小王",30000,rmbStrategy);
            //向小王支付工资
            ctx.pay();
            //准备Jack的支付上下文
            ctx = new PayContext("jack",10000,dollarStrategy);
            //向Jack支付工资
            ctx.pay();
            //创建支付到银行账户的支付策略
            PayStrategy accountStrategy = new AccountPay2("1234567890");
            //准备上下文
            ctx = new PayContext("小张",40000,accountStrategy);
            //向小张的账户支付
            ctx.pay();
        }
    }
    

    控制台输出:

    现在给:小王 人民币支付 30000.0元!
    现在给:jack 美金支付 10000.0dollar !
    现在给:小张的账户:1234567890 支付工资:40000.0 元!

    总结:

    策略模式的优点:
    1. 上下文和具体策略是松耦合关系,因此,上下文只需要知道他要使用耨一个实现Strategy接口类的实例,但不需要知道具体是哪一个类。
    2. 策略模式满足“开-闭原则”,当增加新的具体策略时,不需要修改上下文类的代码,上下文就可以引用新的策略的实例。
    适合使用策略模式的场景:
    1. 一个类定义了多种行为,并且这些行为在这个类的方法中以多个条件语句的形式出现,那么使用策略模式避免在类中使用大量的条件语句。
    2. 程序的主类(相当于上下文角色),不希望暴露复杂的,与算法相关的数据结构,那么可以使用策略模式封装算法,即将算法分别封装到具体策略中。
    3. 需要使用一个算法的不同变体。

    引用一个大佬的总结:

    策略模式的优点:
      1.策略模式的功能就是通过抽象、封装来定义一系列的算法,使得这些算法可以相互替换,所以为这些算法定义一个公共的接口,以约束这些算法的功能实现。如果这些算法具有公共的功能,可以将接口变为抽象类,将公共功能放到抽象父类里面。
      2.策略模式的一系列算法是可以相互替换的、是平等的,写在一起就是if-else组织结构,如果算法实现里又有条件语句,就构成了多重条件语句,可以用策略模式,避免这样的多重条件语句。
      3.扩展性更好:在策略模式中扩展策略实现非常的容易,只要新增一个策略实现类,然后在使用策略实现的地方,使用这个新的策略实现就好了。
    策略模式的缺点:
      1.客户端必须了解所有的策略,清楚它们的不同:
         如果由客户端来决定使用何种算法,那客户端必须知道所有的策略,清楚各个策略的功能和不同,这样才能做出正确的选择,但是这暴露了策略的具体实现。
      2.增加了对象的数量:
        由于策略模式将每个具体的算法都单独封装为一个策略类,如果可选的策略有很多的话,那对象的数量也会很多。
      3.只适合偏平的算法结构:
        由于策略模式的各个策略实现是平等的关系(可相互替换),实际上就构成了一个扁平的算法结构。即一个策略接口下面有多个平等的策略实现(多个策略实现是兄弟关系),并且运行时只能有一个算法被使用。这就限制了算法的使用层级,且不能被嵌套。
    策略模式的本质:
      分离算法,选择实现。
      如果你仔细思考策略模式的结构和功能的话,就会发现:如果没有上下文,策略模式就回到了最基本的接口和实现了,只要是面向接口编程,就能够享受到面向接口编程带来的好处,通过一个统一的策略接口来封装和分离各个具体的策略实现,无需关系具体的策略实现。
      貌似没有上下文什么事,但是如果没有上下文的话,客户端就必须直接和具体的策略实现进行交互了,尤其是需要提供一些公共功能或者是存储一些状态的时候,会大大增加客户端使用的难度;引入上下文之后,这部分工作可以由上下文来完成,客户端只需要和上下文进行交互就可以了。这样可以让策略模式更具有整体性,客户端也更加的简单。
      策略模式体现了开闭原则:策略模式把一系列的可变算法进行封装,从而定义了良好的程序结构,在出现新的算法的时候,可以很容易的将新的算法实现加入到已有的系统中,而已有的实现不需要修改。
      策略模式体现了里氏替换原则:策略模式是一个扁平的结构,各个策略实现都是兄弟关系,实现了同一个接口或者继承了同一个抽象类。这样只要使用策略的客户端保持面向抽象编程,就可以动态的切换不同的策略实现以进行替换。

    展开全文
  • 我们知道Redis是分布式内存数据库,基于内存运行,可是有没有想过比较好的服务器内存也不过几百G,能存多少数据呢,当内存占用满了之后该怎么办...不要怕,本篇我们一起来看一下Redis的内存淘汰策略是如何释放内存的。

    我们知道Redis是分布式内存数据库,基于内存运行,可是有没有想过比较好的服务器内存也不过几百G,能存多少数据呢,当内存占用满了之后该怎么办呢?Redis的内存是否可以设置限制? 过期的key是怎么从内存中删除的?不要怕,本篇我们一起来看一下Redis的内存淘汰策略是如何释放内存的,以及过期的key是如何从内存中删除的。


    目录

    介绍

    内存淘汰策略

    LRU算法

    LFU算法

    ​过期删除策略

    AOF和RDB的过期删除策略


    Redis6系列文章

    Redis系列(一)、CentOS7下安装Redis6.0.3稳定版

    Redis系列(二)、数据类型之字符串String 

    Redis系列(三)、数据类型之哈希Hash

    Redis系列(四)、数据类型之列表List

    Redis系列(五)、数据类型之无序集合Set

    Redis系列(六)、数据类型之有序集合ZSet(sorted_set)

    Redis系列(七)、常用key命令

    Redis系列(八)、常用服务器命令 

    Redis系列(九)、Redis的“事务”及Lua脚本操作

    Redis系列(十)、详解Redis持久化方式AOF、RDB以及混合持久化

    Redis系列(十一)、Redis6新特性之ACL安全策略(用户权限管理)

    Redis系列(十二)、Redis6集群搭建及原理(主从、哨兵、集群)

    Redis系列(十三)、pub/sub发布与订阅(对比List和Kafka)

    Redis系列(十四)、Redis6新特性之RESP3与客户端缓存(Client side caching)

    Redis系列(十五)、Redis6新特性之集群代理(Cluster Proxy)

    Redis系列(十六)、Redis6新特性之IO多线程

    介绍

    开篇提到Redis是基于内存的数据库,当内存满了的时候会发生什么呢?Redis的内存是否可以设置限制? 过期的key是怎么从内存中删除的?

    其实在Redis中是可以设置内存最大限制的,因此我们不用担心Redis占满机器的内存影响其他服务,这个参数maxmemory是可以配置的:

    #配置文件
    maxmemory <bytes>
    下面的写法均合法:
    maxmemory 1024000
    maxmemory 1GB
    maxmemory 1G
    maxmemory 1024KB
    maxmemory 1024K
    maxmemory 1024MB
    ...
    
    #命令行
    127.0.0.1:6379> config get maxmemory
    1) "maxmemory"
    2) "0"
    127.0.0.1:6379> config set maxmemory 1GB
    OK
    127.0.0.1:6379> config get maxmemory
    1) "maxmemory"
    2) "1073741824"

    maxmemory参数默认值为0。因32位系统支持的最大内存为4GB,所以在32位系统上Redis的默认最大内存限制为3GB;在64位系统上默认Redis最大内存即为物理机的可用内存;

    内存淘汰策略

    Redis中共有下面八种内存淘汰策略

    • volatile-lru:设置了过期时间的key使用LRU算法淘汰;
    • allkeys-lru:所有key使用LRU算法淘汰;
    • volatile-lfu:设置了过期时间的key使用LFU算法淘汰;
    • allkeys-lfu:所有key使用LFU算法淘汰;
    • volatile-random:设置了过期时间的key使用随机淘汰;
    • allkeys-random:所有key使用随机淘汰;
    • volatile-ttl:设置了过期时间的key根据过期时间淘汰,越早过期越早淘汰;
    • noeviction:默认策略,当内存达到设置的最大值时,所有申请内存的操作都会报错(如set,lpush等),只读操作如get命令可以正常执行;

    LRU、LFU和volatile-ttl都是近似随机算法;

    使用下面的参数maxmemory-policy配置淘汰策略:

    #配置文件
    maxmemory-policy noeviction
    
    #命令行
    127.0.0.1:6379> config get maxmemory-policy
    1) "maxmemory-policy"
    2) "noeviction"
    127.0.0.1:6379> config set maxmemory-policy allkeys-random
    OK
    127.0.0.1:6379> config get maxmemory-policy
    1) "maxmemory-policy"
    2) "allkeys-random"

    在缓存的内存淘汰策略中有FIFO、LRU、LFU三种,其中LRU和LFU是Redis在使用的。

    FIFO是最简单的淘汰策略,遵循着先进先出的原则,这里简单提一下:

    LRU算法

    LRU(Least Recently Used)表示最近最少使用,该算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”。

    LRU算法的常见实现方式为链表:

    新数据放在链表头部 ,链表中的数据被访问就移动到链头,链表满的时候从链表尾部移出数据。

    而在Redis中使用的是近似LRU算法,为什么说是近似呢?Redis中是随机采样5个(可以修改参数maxmemory-samples配置)key,然后从中选择访问时间最早的key进行淘汰,因此当采样key的数量与Redis库中key的数量越接近,淘汰的规则就越接近LRU算法。但官方推荐5个就足够了,最多不超过10个,越大就越消耗CPU的资源。

    但在LRU算法下,如果一个热点数据最近很少访问,而非热点数据近期访问了,就会误把热点数据淘汰而留下了非热点数据,因此在Redis4.x中新增了LFU算法。

    在LRU算法下,Redis会为每个key新增一个3字节的内存空间用于存储key的访问时间;

    LFU算法

    LFU(Least Frequently Used)表示最不经常使用,它是根据数据的历史访问频率来淘汰数据,其核心思想是“如果数据过去被访问多次,那么将来被访问的频率也更高”。

    LFU算法反映了一个key的热度情况,不会因LRU算法的偶尔一次被访问被误认为是热点数据。

    LFU算法的常见实现方式为链表:

    新数据放在链表尾部 ,链表中的数据按照被访问次数降序排列,访问次数相同的按最近访问时间降序排列,链表满的时候从链表尾部移出数据。


    过期删除策略

    前面介绍的LRU和LFU算法都是在Redis内存占用满的情况下的淘汰策略,那么当内存没占满时在Redis中过期的key是如何从内存中删除以达到优化内存占用的呢? 

    官网:https://redis.io/commands/expire#expire-accuracy 

    在Redis中过期的key不会立刻从内存中删除,而是会同时以下面两种策略进行删除:

    • 惰性删除:当key被访问时检查该key的过期时间,若已过期则删除;已过期未被访问的数据仍保持在内存中,消耗内存资源;
    • 定期删除:每隔一段时间,随机检查设置了过期的key并删除已过期的key;维护定时器消耗CPU资源;

    Redis每10秒进行一次过期扫描:

    1. 随机取20个设置了过期策略的key;
    2. 检查20个key中过期时间中已过期的key并删除;
    3. 如果有超过25%的key已过期则重复第一步;

    这种循环随机操作会持续到过期key可能仅占全部key的25%以下时,并且为了保证不会出现循环过多的情况,默认扫描时间不会超过25ms;

    AOF和RDB的过期删除策略

    前面介绍了Redis的持久化策略RDB和AOF,当Redis中的key已过期未删除时,如果进行RDB和AOF的持久化操作时候会怎么操作呢?

    • 在RDB持久化模式中我们可以使用savebgsave命令进行数据持久化操作
    • 在AOF持久化模式中使用rewriteaofbgrewriteaof命令进行持久化操作

    这四个命令都不会将过期key持久化到RDB文件或AOF文件中,可以保证重启服务时不会将过期key载入Redis。

    为了保证一致性,在AOF持久化模式中,当key过期时候,会同时发送DEL命令给AOF文件和所有节点;

    从节点不会主动的删除过期key除非它升级为主节点或收到主节点发来的DEL命令;

     

    希望本文对你有帮助,请点个赞鼓励一下作者吧~ 谢谢!

     

    展开全文
  • if else终结者——策略模式

    千次阅读 多人点赞 2021-05-28 10:48:15
    你是不是还在写着大量的if else语句,if else 不仅难以维护不易扩展,而且使代码臃肿不堪,想不想让你的业务代码更加的健壮,更易扩展,那你一定要学一学今天的主角策略模式。学会了策略模式的使用让会你的代码更加...
  • 上期CTP API C++ 源代码 多合约多策略版(更新) 下载文件名上期:CTP_API_C++可实盘多合约多策略版本源代码(更新).rar 是"上期CTP_API_C++可实盘的源代码(更新).rar"的升级版 填入经纪公司代码,实盘帐号,密码即可。 ...
  • 策略模式:如果某种行为拥有多种运作方式,那么把这种行为视为一种策略,把这些运作方式视为策略实现,这些策略实现之间可以相互替换。 这样,行为调用方就可以在运行时,根据不同的需求,将相应的策略实现当做参数...
  • 2、日内策略 日内策略主要是通道突破类策略,除去均线、boll 线,常见日内策略还有Dual Thrust策略、R-Breaker 策略、菲阿里四价策略、空中花园策略等。这几个策略都属于通道突破策略策略的核心都在于通道上下轨...
  • 华为策略路由原理与实验

    千次阅读 2021-01-20 18:32:37
    策略路由PBR是一种依据用户制定的策略进行路由选择的机制,分为本地策略路由、接口策略路由和智能策略路由SPR。本课程仅讨论本地策略路由。 IP单播策略路由具有如下优点: 可以根据用户实际需求制定策略进行路由...
  • 全面了解风控策略体系

    万次阅读 多人点赞 2020-06-28 14:09:48
    模型和策略的开发是一个系统工程,这其中需要有业务经验、统计理论、算法运用、和数据认知,是一个不断反思,不断积累经验的过程。沙滩上建不起摩天大楼。扎扎实实的基本功永远有价值,永远不会过时。
  • 【vn.py】量化策略开发

    千次阅读 2019-08-06 15:27:10
    一个完整的量化流程至少需要包括策略开发、历史回测与实盘交易三个步骤,下面就以vn.py为例,先整理一下vn.py中如何进行量化策略的开发。 开发环境 在vn.py的官方教程中使用的IDE是VS Code,这里的IDE没有什么特殊...
  • 策略梯度

    千次阅读 2019-03-08 21:47:56
    Policy Gradient Methods for Reinforcement Learning with Function Approximation(PG) ...基于策略的学习可能会具有更好的收敛性,这是因为基于策略的学习虽然每次只改善一点点,但总是朝着好的方向在改善;...
  • 趋势性动量策略有效性验证及实现1相关性验证2策略概要3其他回测结果其他量化策略 1相关性验证 选取上证指数000001.SH,获取收盘价 以50为单位,计算每个55天的收益序列。 使用shift(1),获得滞后一个时间段(50天)...
  • 策略模式(策略设计模式)详解

    千次阅读 2019-05-23 17:30:35
    策略模式(策略设计模式)详解 在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况,例如,出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等,超市促销可以釆用打折、送商品、送积分等方法。 ...
  • 行业轮动策略(附策略源码)

    千次阅读 2019-06-25 13:31:43
    行业轮动策略简介 什么是行业轮动策略? ​ 行业轮动是利用市场趋势获利的一种主动交易策略,其本质是利用不同投资品种强势时间的错位对行业品种进行切换以达到投资收益最大化的目的。通俗点讲就是根据不同行业的...
  • 我认为quant(策略quant)的核心是策略,底层基础是系统。策略可以个逻辑,简单到我就要买或者卖,也可以是个复杂的模型。而支撑的是平稳测试和执行人的想法或者模型的系统,包括backtesting,模拟盘,风控,择时...
  • 严格劣势策略和弱劣势策略

    千次阅读 2021-01-23 19:36:42
    请用一个包含两个人参与的博弈矩阵来举例说明,要求其中一个参与者有三个策略且三者之一为严格劣势策略,另一个参与者有三个策略但三者之一为弱劣势策略,请指出你所举例子中的劣势策略。     &...
  • 量化基金投资常用策略简介

    千次阅读 2020-09-26 13:13:11
    套利策略 套利:利用同一商品(或相似商品)在不同市场上的差价,进行低买高卖的交易行为。 很容易理解,其实现实生活中处处存在着套利: 小A从某多多上团购价入手了一批商品,价格较低,放在某鱼上原价卖出 小B从...
  • 文章目录双均线策略(Double MA)DoubeMA源码分析1、策略类初始化2、策略初始化3、策略启动4、接收Tick数据5、处理Bar数据6、订单以及交易的回调7、策略结束流程框图 双均线策略(Double MA) 双均线策略作为最常见...
  • 路由策略 & 策略路由

    万次阅读 多人点赞 2019-08-29 11:45:43
    策略路由PBR(Policy-Based Routing)是一种依据用户制定的策略进行路由选择的机制,分为本地策略路由、接口策略路由和智能策略路由SPR(Smart Policy Routing)。 策略路由具有如下优点: 可以根据用户实际需求...
  • 配置密码策略

    千次阅读 2020-01-15 16:01:07
    密码策略介绍 密码策略是操作系统针对系统安全提供的一种安全机制,就好像linux操作系统不提供超级用户登录一样,密码策略包括:密码最小长度、密码使用期限、历史密码、密码复杂度等,在企业里面都是要求对操作...
  • Win7 Home启动组策略编辑器所需要的文件

    千次下载 热门讨论 2012-06-21 14:34:47
    WIN7的家庭普通版是没有组策略的不包含这个功能。 1、将Windows 7版中(运行了Windows 7的更高级的版本的电脑上)的"WINDOWS\system32”文件夹中的gpedit.msc、fde.dll、gpedit.dll、gptext.dll、wsecedit.dll文件...
  • 深入解析策略模式

    万次阅读 多人点赞 2019-03-02 12:28:31
    在讲策略模式之前,我们先看一个日常生活中的小例子:  现实生活中我们到商场买东西的时候,卖场往往根据不同的客户制定不同的报价策略,比如针对新客户不打折扣,针对老客户打9折,针对VIP客户打8折...  现在...
  • 华为防火墙安全策略

    千次阅读 2020-12-11 10:48:39
    1初识安全策略 小伙伴们,我们试想下如果防火墙把所有流量都拒绝了,内部用户将无法畅游网络,外部合法用户将无法访问内部资源。因此我们需要配置防火墙的一个特性,让它更好的实现防火墙的功能,这个特性就是安全...
  • 标准分片策略 复合分片策略 行表达式分片策略 Hint分片策略 准备工作 先创建两个数据库 ds-0、ds-1,两个库中分别建表 t_order_0、t_order_1、t_order_2 、t_order_item_0、t_order_item_1、t_order_item_2 6张表,...
  • VNPY - CTA策略模块策略开发

    千次阅读 2019-04-02 18:41:25
    策略模板 一般来说,交易策略的思路主要来源于两个方向:第一、实盘中的交易经验总结;第二、数据挖掘、统计分析得到的规律。...策略模板是具体交易策略的基础,一般把大部分策略都用到的方法和公共变量放到策略...
  • 本文将向大家介绍四种常见的CTA策略(Dual Thrust、R-Breaker、菲阿里四价、空中花园),实现各策略并以Dual Thrust为例进行参数优化及止盈止损分析对比。 1、常用日内CTA 策略简介 1.1 Dual Thrust策略  Dual ...
  • 原来使用 Spring 实现策略模式可以这么简单!

    千次阅读 多人点赞 2021-02-01 11:07:36
    策略模式作为一种软件设计模式,指对象有某个行为,但是在不同的场景中,该行为有不同的实现算法,可以替代代码中大量的 if-else。比如我们生活中的场景:买东西结账可以使用微信支付、支付宝...
  • 文章目录设计模式 - 与springboot 集成的复合策略模式,支持多策略多组合1、意图2、实例1、创建策略策略组接口2、...设计模式 - 与springboot 集成的复合策略模式,支持多策略多组合 1、意图 1、为了解决算法类似...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,896,966
精华内容 758,786
关键字:

策略