edis

先删缓存再更新数据库再重新加载缓存。对于解决现实业务问题那么这个问题其实是一个业务设计问题而不是技术问题，答案取决于修改是否需要实时生效，是否允许查看价格与结算价格存在不一致，是否需要严格的一致性等等，进而从价格的修改业务流程上进行设计。

题主是否想询问“rediswatchdog如果阻塞的解决方法是什么？”rediswatchdog阻塞的解决方法是检查Redis服务器的负载情况和检查系统日志。1、检查Redis服务器的负载情况：检查Redis服务器的负载情况，确保硬件资源足够，并且Redis数据库的配置合理。2、检查系统日志：检查系统日志，查看是否有其他进程或线程占用了系统资源，或者RedisWatchdog线程本身存在问题。

MongoDB[1] 是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。Solr是一个独立的企业级搜索应用服务器，它对外提供类似于Web-service的API接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的XML文件，生成索引；也可以通过Http Get操作提出查找请求，并得到XML格式的返回结果。

对于在Rails上使用Redis Store，首先我们需要在Gemfile文件中添加入口gem "redis-rails"gem "redis-rack-cache" # optional然后我们就会有如下选择: ## Cache Store# config/environments/production.rbconfig.cache_store = :redis_store## Session Store# config/initializers/session_store.rbMyApplication::Application.config.session_store :redis_store,servers: ["redis://:secret@192.168.6.23:6379/0", "redis://:secret@192.168.6.99:6379/1"]## HTTP Cache# config.rurequire "rack"require "rack/cache"require "redis-rack-cache"use Rack::Cache,metastore: "redis://localhost:6379/0/metastore",entitystore: "redis://localhost:6380/0/entitystore"如你所见，使用这个插件相当简单，但现在我要教你如何去管理这些设置。第一个案例不言自明，我们来说说用 ActiveSupport 来加载Redis Store。这里请记住，Redis的contraire仅仅只能支持字符串，所以可以利用序列化与反序列化技术来存储任何对象。这里的第二个案例就稍微复杂一点。首先，我们需要使用一个服务器集群。这里再重复一遍，Redis Store支持分片，也就意味着Http会话在两台服务器之间都是互相透明可见的。最后一个案例主要涉及到Ruby的Http缓存代理，这些缓存的主要作用就是为了加快Http响应，而且也是以名值对的方式来存储meta数据以及entity实体对象的，这里也提一下，如果我们存储的都是普通的字符串文本，那么 mashalling模块也是不需要启动的。虽然说了这么多，但就上面几点也只是 Redis store 所有功能的一小部分而已，其实它还支持Rack,Sinatra以及I18n。总结我个人认为 Redis 基本算是你的服务器环境必须用用的一个插件，它速度快而且可使用范围广泛，比如可以作为数据库，缓存，分片机等等，真算得上是一个不错的工具。然而任何好处都是有代价的：与Rails一样，为了使用它，你必须花费大量的时间与安装与配置才能在性能，以及内存使用上找到一个绝佳的平衡点。您可能感兴趣的文章:

首先在Redis-cli中使用XADD命令插入一条数据 查看对象编码 可以看到对象的数据类型为stream，返回的streamID 的基本结构为 "{timestamp}-{sequence}" 使用XINFO命令查看该 stream Key 的基本信息 可以看到stream中使用了一种 "radix-tree" 数据结构。 Radix树对上述单词的存储 当插入first时 相比于普通的字典树，Radix树会将单节点树枝压缩为一个节点，以节省存储空间，提高搜索的效率。在Streams结构中，默认生成的StreamID为 时间戳+自增序列号 的形式，当消息的时间分布紧凑时，这种存储结构多个StreamID复用的前缀将很长，可以将存储空间压缩得很小，这对于内存使用内存存储数据的Redis很重要。Radix树的另一个优点是解决了hash冲突的问题。对于一般的hash结构，当遇到hash冲突的情况，一般采用链地址法的方式解决冲突。这样一个hash槽中的链可能会很长，如果采用扩容的方式，执行效率一般也不是很高。采用树结构索引数据解决了hash冲突的问题。当然，Radix树在遇到新插入的数据时也会遇到数据节点拆分的问题。 stream 是一种 append-only 的数据结构，只有 del 命令可以删除对应的Key。 指定添加数据的最大长度（~表示只在节点删除时清除数据，能保证数据个数的最大长度不小于 LENGTH 个，不需要每次调整Radix树，性能相对较好） 阻塞式，获取最新1条的数据（阻塞单位：ms） 根据Streams支持的命令，要使用Streams作为多消费队列，主要有以下几点： 官网介绍 中文官网命令介绍 图解Redis数据结构，讲的比较好 知乎上基于Redis消息队列方案介绍

不知道你说的watch是啥意思，php操作redis很简单的，举个例子：<?php //连接本地的 Redis 服务 $redis = new Redis(); $redis->connect("127.0.0.1", 6379); echo "Connection to server sucessfully"; //设置 redis 字符串数据 $redis->set("tutorial-name", "Redis tutorial"); // 获取存储的数据并输出 echo "Stored string in redis:: " . $redis->get("tutorial-name");?>这是操作字符串的，还有操作其他redis数据类型的。要成功先确保你php有装redis扩展，并且本地redis服务正常跑着的。如果没有解决你的问题的话，麻烦你解释一下问题吧，你看都没人回你，因为你问题不清楚啊。如果解决了，就请采纳吧。

1、redis事物通过multi命令开始。这条命令总是返回ok。2、然后用户可以执行多条指令，redis不会马上执行这些指令，还只是放入到队列中。3、当执行exec指令时，所有的指令执行。4、调用discard指令，将会flush事物队列，并且退出事物。如下:redis127.0.0.1:6379multiokredis127.0.0.1:6379setfoo1queuedredis127.0.0.1:6379incrfooqueuedredis127.0.0.1:6379incrfooqueuedredis127.0.0.1:6379exec1)ok2)(integer)23)(integer)3如以下：redis127.0.0.1:6379multiokredis127.0.0.1:6379sett13queuedredis127.0.0.1:6379lpoptqueuedredis127.0.0.1:6379exec1)ok2)(error)erroperationagainstakeyholdingthewrongkindofvalue对于这种err，需要客户端给予合理的提示。需要注意的是，所有在队列中的指令都会被执行，redis不会终止指令的执行(事物中有指令失败事物不会终止在这条失败的指令上)。三、mutil总是返回ok，然后调用get，set写数据，这些指令会被提交到队列，discard取消命令队列，不执行事物：discard为取消命令队列。可以终断一个事物。不会有命令会被执行，并且连接的状态是正常的。如:setfoo1okmultiokincrfooqueueddiscardokgetfoo"1"四、redis的optimisticlockingusingcheck-and-set(乐观锁)，实现get，set命令序列数据的原子性：watch指令在redis事物中提供了cas的行为。为了检测被watch的keys在是否有多个clients改变时引起冲突，这些keys将会被监控。例如:一个key自增长(假设redis不提供incr的功能)val=getmykeyval=val+1setmykey$val以上指令执行，如果是单一的client，整个操作是没问题的。如果多个client在同一时间操作。如clienta与clientb读取了老的值，假如是10，这个值在两个client将会被增长到11，最后set这个key值时，这个key最终是11还不是12.watch能够很好的处理这种问题:watchmykeyval=getmykeyval=val+1multisetmykey$valexec使用以上代码，如果在执行watch与exec指令这段时间里有其它客户端修改此key值，此事物将执行失败。以上形式的锁被称为乐观锁。

一般疑问句。

同学你好！此句是一个选择疑问句，选择疑问句的特点是：一般疑问句 + or + 被选择部分所以此句的前半句Is he a French student？“他是法国学生吗？”是一个一般疑问句。而当我们把or后面的Swedish student 与前面的a French student相比较时，就会发现这两个短语不对称，所以我们可以发现是Swedish student 前少了一个冠词a。所以此题是选择疑问句or前后的两个成分不统一，在Swedish前加一个a即可。希望我的答案可以对你有所帮助！祝英语越来越好！

同学你好！此句是一个选择疑问句，选择疑问句的特点是：一般疑问句+or+被选择部分所以此句的前半句IsheaFrenchstudent？“他是法国学生吗？”是一个一般疑问句。而当我们把or后面的Swedishstudent与前面的aFrenchstudent相比较时，就会发现这两个短语不对称，所以我们可以发现是Swedishstudent前少了一个冠词a。所以此题是选择疑问句or前后的两个成分不统一，在Swedish前加一个a即可。希望我的答案可以对你有所帮助！祝英语越来越好！

What"s your nationality?国籍是什么

这个句子可以这样问Where are her friends from?

你好! Are you Swedish? 中文意思是：你是瑞典人吗？这是一个一般疑问句。句子结构是：主系表。

那就是课本错了么 瑞点是什么

　本身已经是单数了。Are you Swedish? 为你解答，如有帮助请采纳，如对本题有疑问可追问，Good luck!

你究竟要表达些什么？不是swedish是Swedish瑞典的，瑞典人是固有名词而french是French法国的，faguoren意思是固有名词

1 What nationality is her car? 2 What nationality is he? 3 What nationality is her? 4 What nationality is his car?

这是问国籍，可以说：1. Where are you from?2. Where do you come from?3. What"s your nationality?4. Are you Swedish?

这是一辆沃尔沃汽车，瑞典的。

Swedishes

是不可数， 即The Swedish, The Danish 是复数We are Swedish，We are Danish 里 的 Swedish， Danish 不仅是专有词， 也是形容词（不是名词）。We are Swedish，We are Danish 的意思是 We are Swedish people，We are Danish people 。

不可以 Swedish是集体名词,瑞典人的（统称）,无单复数形式 说瑞典人 the Swedish one Swede two Swedes

swedish意式是瑞典语，因此它也可以表示瑞典。瑞典是北欧五国之一，早在石器时代就有人类居住的痕迹，历史极为悠久，其工业发达，在医药研究、电子行业领域等方便都处于世界领先地位，经济高度发达。Swedish Form (Svensk Form)斯德哥尔摩排名第 304 的景点体验在瑞典，农业比重较小，而工业发达，它拥有全球领先的点电讯业和医药研究能力，在电子行业也处于世界领先的地位，经济高度发达，以高收入、高税收、高福利为主要内容保障国家经济发展，从而抵御各种危机

1、Swedish英[u02c8swiu02d0du026au0283]美[u02c8swiu02d0du026au0283]，adj.瑞典的; 瑞典人的; 瑞典语的; 瑞典文化的;n.瑞典语。 2、[例句]Are they talking Swedish or Danish?他们说的是瑞典语还是丹麦语？

1、wedish的意思是瑞典语，因此它指代的国家是瑞典。瑞典是北欧五国之一，更是北欧最大的国家，首都为斯德哥尔摩，交通便捷，和多个国家为邻，经济发展迅速。2、早在石器时代，瑞典已经开始有人类居住的痕迹，其历史是非常悠久的，在1611年到1721年间的瑞典帝国，更是欧洲列强之一，现如今，瑞典已成为世界上一个永久的中立国、3、在瑞典，农业比重较小，而工业发达，它拥有全球领先的点电讯业和医药研究能力，在电子行业也处于世界领先的地位，经济高度发达，以高收入、高税收、高福利为主要内容保障国家经济发展，从而抵御各种危机。

1、Swedish英[?swi?d??]美[?swi?d??]，adj.瑞典的; 瑞典人的; 瑞典语的; 瑞典文化的;n.瑞典语。2、[例句]Are they talking Swedish or Danish?他们说的是瑞典语还是丹麦语？

啊？ ？我是不是已经回答了吗？ ？ Norweigian丹麦瑞典荷兰挪威丹麦瑞典荷兰的Norweigian丹麦人瑞典人荷兰人相应的各个国家（一般不复杂，你真的要添加的，没什么可说的）所有这些要求，我公司可说这些一点点的差别，但也是正确的，是错误的。说，一个专门术语的语言（英语，法语等）至于的关系，的一些特性是一个很好的判断，如xxxxxsh xxxxxch，这是一种特殊的类似的后缀设置。有xxxman的话是这样的人关注。 没有讨论这些事情，学习英语的学校很长一段时间自然就会有这种感觉。现在记住就行了。 问题来找我，但我通常不在家。

很明显，第一个是正确的。 第一个回答翻译过来就相当于“我不确定，她可能是瑞典人。”第二种回答虽然是通顺的，但没有答到重点，“She may have been Swedish”是过去完成时的被动语态（从过去某个时间里发生——现在为止），人家问：“你认为她是瑞典人吗？”，而第二种答法：“我不确定，她可能从过去某时刻到现在为止一直都是瑞典人。”这样回答显然是没有必要的而且若这样回答就必须要有依据才行，因此正常人是不会这样回答的，故不能选。

一个是“你”本人，另一个是指”你的”朋友，因此一个用you,而另一个用your。明白吗？

Dansk(丹麦语),Norsk(英语的挪威语),suomi(芬兰语的芬兰),Swedish(英语的瑞典语)

是个集合名词，就像Chinese

无单复数

瑞典的英语"Swedish"的读音是/u02c8swiu02d0du026au0283/。1.瑞典语的发音特点瑞典语是一种北日耳曼语，与英语属于同一个语族。它的发音特点与英语有些差异，包括元音和辅音的发音方式以及重音的位置。在瑞典语中，元音和辅音的发音通常比较清晰，而不像英语中那样模糊和连读。2.元音的发音瑞典语有九个元音音素，分为短元音和长元音。其中短元音包括/i,u026a,e,u025b,a,u0254,o,u,u028a/，长元音包括/iu02d0,eu02d0,u025bu02d0,au02d0,u0254u02d0,ou02d0,uu02d0/.这些元音在组成单词时，会根据音节的位置和重音的位置有所变化。3.辅音的发音瑞典语中的辅音比较多，其中有些辅音的发音与英语相似，例如/b,d,f,h,k,l,m,n,p,s,t,v/等。但也有一些辅音在瑞典语中有不同的发音，例如/r,u0283,u0267/等。4.重音的位置瑞典语的重音通常落在单词的第一个音节上，但也有一些例外情况。重音的位置对于单词的意义和语法起着重要的作用，因此正确的重音位置对于正确理解和发音单词是至关重要的。5.英语中的Sw-[iu02d0]-sh发音"Swedish"这个单词中的"Sw-"部分的发音与英语中的/sw-/相似，即/s/和/w/的组合发音。而"-ish"部分的发音则与英语中的/u026au0283/相似，即/i/和/u0283/的组合发音。所以，"Swedish"的整体发音为/u02c8swiu02d0du026au0283/。总结：瑞典的英语"Swedish"的读音为/u02c8swiu02d0du026au0283/，其中"Sw-"的发音与英语中的/sw-/类似，而"-ish" 的发音与英语中的/u026au0283/类似。瑞典语的发音特点包括元音和辅音的发音方式以及重音的位置。了解这些发音特点可以帮助我们更准确地学习和发音瑞典语。

Swedish

没有复数形式。Swedish做名词解释时，有两个含义：① 瑞典语② the Swedish 瑞典人（当做集合名词看待，复数含义）

Swedish是瑞典人的总称，即可表示单数也可表示复数，所以应该是Swedish而不是Swedishes。如：Swedish industry has of late years grown with leaps and bounds. 瑞典的工业近年来飞跃增长。 扩展资料 　　例句： 　　Swedish industrial front is developing by leaps and bounds in the late years. 　　瑞典的工业近年来出现了跃进的`局面。 　　Are they talking Swedish or Danish? 　　他们说的是瑞典语还是丹麦语？ 　　She spoke not only her native language, Swedish, but also English and French 　　她不仅讲自己的母语瑞典语，还讲英语和法语。 　　He was a consultant to the Swedish government. 　　他是瑞典政府顾问。

1、wedish的意思是瑞典语，因此它指代的国家是瑞典。瑞典是北欧五国之一，更是北欧最大的国家，首都为斯德哥尔摩，交通便捷，和多个国家为邻，经济发展迅速。 2、早在石器时代，瑞典已经开始有人类居住的痕迹，其历史是非常悠久的，在1611年到1721年间的瑞典帝国，更是欧洲列强之一，现如今，瑞典已成为世界上一个永久的中立国、 3、在瑞典，农业比重较小，而工业发达，它拥有全球领先的点电讯业和医药研究能力，在电子行业也处于世界领先的地位，经济高度发达，以高收入、高税收、高福利为主要内容保障国家经济发展，从而抵御各种危机。

瑞典。瑞典王国（瑞典语：Konungariket Sverige），通称瑞典（瑞典语：Sverige），是一个位于斯堪的纳维亚半岛的北欧国家，首都为斯德哥尔摩。瑞典西邻挪威，东北与芬兰接壤，西南濒临斯卡格拉克海峡和卡特加特海峡，东边为波罗的海与波的尼亚湾，与丹麦、德国、波兰、俄罗斯、立陶宛、拉脱维亚和爱沙尼亚隔海相望，国土西南端通过厄勒海峡大桥与丹麦相连。瑞典面积为450,295平方公里，为北欧第一大国家，人口约1,000万。64%的国土由森林覆盖，人口密度低（每平方公里仅25人），只有都会地区人口密度较高，87%的人口居住在只占国土面积1.5%的城市里。瑞典是传统的铁、铜和木材出口国，其水资源也很丰富，但石油和煤矿资源十分匮乏。随着运输和通讯的进步，这些自然资源也能够更大规模地从各地开采，尤其是木材与铁矿。地理瑞典位于欧洲北部，斯堪的纳维亚半岛的东部，东面濒波罗的海和波的尼亚湾，因此有漫长的海岸线。西面为斯堪的纳维亚山脉，也是和挪威的分界线。瑞典国土总面积为449,964平方公里（173,720平方英里），可耕地比率约占7.0%，欧洲国家面积排名第五位，也是北欧最大的国家。瑞典地形狭长，南北长1574公里，东西最宽仅500公里，地势自西北向东南倾斜。从地理上分成三个大的地区，北部为诺尔兰高原，山岚起伏，大片辽阔的森林；斯韦阿兰位于中南部，多为平原或丘陵，湖泊约9万个；最南部为约塔兰，由斯莫兰高地和肥沃的斯科讷平原组成。大约有15%的瑞典国土位于北极圈以北。哥得兰岛和厄兰岛是瑞典最大的岛屿；维纳恩湖、韦特恩湖和梅拉伦湖是瑞典最大的湖泊。南部的厄勒地区和中部的梅拉伦湖周边则人口密度最高。

swedish是瑞典。瑞典王国，通称瑞典，是一个位于斯堪的纳维亚半岛的北欧国家，首都为斯德哥尔摩。西邻挪威，东北与芬兰接壤，西南濒临斯卡格拉克海峡和卡特加特海峡，东边为波罗的海与波的尼亚湾，与丹麦、德国、波兰、俄罗斯、立陶宛、拉脱维亚和爱沙尼亚隔海相望，国土西南端通过厄勒海峡大桥与丹麦相连。主要景点1、斯德哥尔摩王宫坐落在老城区的斯塔丹岛上，是瑞典国王办公和举办庆典的地方。王宫始建于中世纪，较早是一个军事堡垒，17世纪末期经过逐步改造、扩建，成了今日的王宫。2、皇后岛宫瑞典首个世界遗产，这里有着历史悠久、气势恢宏的两座古老建筑：中国宫和皇后岛剧院，至今，皇后岛的城堡部分依然居住着瑞典皇室。3、斯德哥尔摩大教堂位于皇宫和诺贝尔博物馆之间，是老城古老的教堂，也是瑞典砖砌哥特式建筑的重要代表。教堂建造于13世纪（中世纪），是市区内古老的教会。因为火灾等原因数次改建和增建，一直到了15世纪后半叶，考虑到与皇宫的均衡性，才确定了整体的建筑外观，承袭着意大利巴洛克样式。以上内容参考 百度百科--瑞典

swedish，英语单词，主要用作形容词、名词，作形容词时译为“瑞典的；瑞典语的；瑞典人的”，作名词时译为“瑞典语；瑞典人”。swedish单词用法1、ADJSwedish means belonging or relating to Sweden, or to its people, language, or culture. 瑞典的；瑞典人的；瑞典语的；瑞典文化的。2、N-UNCOUNTSwedish is the language spoken in Sweden. 瑞典语。swedish短语搭配1、Swedish Academy 瑞典学院 ; 瑞典皇家科学院 ; 瑞典文学院。2、swedish phonology 瑞典语发音 ; 瑞典语音系学。3、Swedish Institute 瑞典对外交流委员会 ; 瑞典学会 ; 瑞典学院 ; 瑞典协会。4、Swedish amber 瑞曲琥珀。5、Swedish Elkhound 瑞典猎鹿犬 ; 瑞典猎麋犬。

swedish，英语单词，主要用作形容词、名词，作形容词时译为“瑞典的；瑞典语的；瑞典人的”，作名词时译为“瑞典语；瑞典人”。美[_swid__]英[_swi_d__]n.瑞典语；〈集合词〉瑞典人.adj.瑞典(式)的；瑞典人[语]的,网络瑞典的；瑞典文；瑞典式。Youprobablyalreadyknowit"sgoodforyou,butIfoundarecentSwedishstudythatgivesusmoreevidence.或者你已经知道距好有益，但系我刚刚从某个瑞典噶研究入面发现左更多证据去证实酸奶噶好处喔。一站式出国留学攻略 http://www.offercoming.com

通过拆解单词来记忆。swedish adj.瑞典的1.联想方式:swe(甜）dish(菜）记忆方法:瑞典的菜很甜2.联想方式:s（使）w（我）e（饿）di（地）s（死）h（好）记忆方法:瑞典的食物使我饿地要死，好吃！3.联想方式:s(使)w(我)e(饿)di(地)s(死)h(喝)记忆方法:瑞典的食物使我饿地要死,只有喝水

// 创建请求ID标志, uniqid 无法保证唯一, 自己去搜索生成唯一的方法$uuid = uniqid();$tsk_name = "mytask";$time_out = 30000; // 超时策略: 30秒$time_start = time();$redis->rPush($tsk_name, $uuid); // 右(后)插入队列// 堵塞等待队列中第一个和$uuid匹配的(到我了)while($uuid != $redis->lGet($tsk_name, 0)){ if((time()-$time_start)> $time_out) { break; // 超时跳出(某些原因队列异常了, 可能永远取不到) } usleep(10); // sleep 10ms, 再次尝试}// 这里执行任务的处理代码....// $response 已拼装好要返回的内容// 处理完成后(数据库等已入库更新), 需要:if($redis->lGet($tsk_name, 0) == $uuid){ // 再次确认第一个是本请求 $redis->lPop($tsk_name); // 完成任务了, 从队列中移除}else{ // 出现这种情况, 是因为超时了, 或前面的$uuid没有被消费 // 若不清除, 后续的请求, 都将无法正常进入队列执行 // 取队列中的所有$uuid $queues = $redis->lRange($tsk_name, 0, -1); foreach($queues as $i=>$uid){ if($uid==$uuid){

Redis Sentinel简介Sentinel(哨兵)进程是用于监控redis集群中Master主服务器工作的状态，在Master主服务器发生故障的时候，可以实现Master和Slave服务器的切换，保证系统的高可用，其已经被集成在redis2.6+的版本中，Redis的哨兵模式到了2.8版本之后就稳定了下来。一般在生产环境也建议使用Redis的2.8版本的以后版本。哨兵(Sentinel) 是一个分布式系统，你可以在一个架构中运行多个哨兵(sentinel) 进程，这些进程使用流言协议(gossipprotocols)来接收关于Master主服务器是否下线的信息，并使用投票协议(Agreement Protocols)来决定是否执行自动故障迁移,以及选择哪个Slave作为新的Master。每个哨兵(Sentinel)进程会向其它哨兵(Sentinel)、Master、Slave定时发送消息，以确认对方是否”活”着，如果发现对方在指定配置时间(可配置的)内未得到回应，则暂时认为对方已掉线，也就是所谓的”主观认为宕机” ，英文名称：Subjective Down，简称SDOWN。有主观宕机，肯定就有客观宕机。当“哨兵群”中的多数Sentinel进程在对Master主服务器做出 SDOWN 的判断，并且通过 SENTINEL is-master-down-by-addr 命令互相交流之后，得出的Master Server下线判断，这种方式就是“客观宕机”，英文名称是：Objectively Down， 简称 ODOWN。通过一定的vote算法，从剩下的slave从服务器节点中，选一台提升为Master服务器节点，然后自动修改相关配置，并开启故障转移（failover）。哨兵(sentinel) 虽然有一个单独的可执行文件 redis-sentinel ,但实际上它只是一个运行在特殊模式下的 Redis 服务器，你可以在启动一个普通 Redis 服务器时通过给定 --sentinel 选项来启动哨兵(sentinel)，哨兵(sentinel) 的一些设计思路和zookeeper非常类似。Sentinel集群之间会互相通信，沟通交流redis节点的状态，做出相应的判断并进行处理，这里的主观下线状态和客观下线状态是比较重要的状态，它们决定了是否进行故障转移，可以 通过订阅指定的频道信息，当服务器出现故障得时候通知管理员，客户端可以将 Sentinel 看作是一个只提供了订阅功能的 Redis 服务器，你不可以使用 PUBLISH 命令向这个服务器发送信息，但你可以用 SUBSCRIBE 命令或者 PSUBSCRIBE 命令， 通过订阅给定的频道来获取相应的事件提醒。一个频道能够接收和这个频道的名字相同的事件。 比如说， 名为 +sdown 的频道就可以接收所有实例进入主观下线（SDOWN）状态的事件。 Sentinel（哨兵）进程的作用：1、监控(Monitoring): 哨兵(sentinel) 会不断地检查你的Master和Slave是否运作正常。2、提醒(Notification)：当被监控的某个Redis节点出现问题时, 哨兵(sentinel) 可以通过 API 向管理员或者其他应用程序发送通知。3、自动故障迁移(Automatic failover)：当一个Master不能正常工作时，哨兵(sentinel) 会开始一次自动故障迁移操作，它会将失效Master的其中一个Slave升级为新的Master, 并让失效Master的其他Slave改为复制新的Master；当客户端试图连接失效的Master时，集群也会向客户端返回新Master的地址，使得集群可以使用现在的Master替换失效Master。Master和Slave服务器切换后，Master的redis.conf、Slave的redis.conf和sentinel.conf的配置文件的内容都会发生相应的改变，即，Master主服务器的redis.conf配置文件中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

medisana不是贴牌。作为源自欧洲德国的轻医美健康护理品牌，medisana成立有40年，其产品涉及健康及医疗器械、家居环境和个人护理等领域，致力于为所有具有自我健康意识的消费者所服务。其产品在11个国家设有分公司和分销商，用户已超过35个国家，规模程度大。发展初期，medisana以医疗级别的健康产品为主要生产线，后来逐渐将产品延伸至美容护理领域，拥有强大的专业技术积累，由medisana推出的小极光冰感美肤脱毛仪在专业和安全性方面都有保障。medisana血氧仪怎么样：血氧仪最重要的一点就是测量的准确性，medisana这一款血氧仪自然也是做到了一点，并有着医用级测量标准，其血氧测量的精准度达到国际标准，并在针对测量准确性上，增添了以下设计：首先是在仪器性能上，配置是进口优势芯片，即便是针对弱脉搏的情况也能进行精准的识别，不会因为脉搏强弱而影响测量效果，即便是在脉搏强度低至0.3%时也无所畏惧。在使用仪器的时候都输通过手指进行测量的。所以这一款血氧仪就采用了专利手指定位线，在这测量原理下保证手指放对的准确性更高，以次获得更精准的数据采集。为了防止光源干扰测量，仪器采用了环形硅胶遮光的细节设计。这样在进行测量的时候就可以通过环形硅胶遮光层，来减少环境强光环的干扰，保证更灵敏、更准确的进行测量。

SomaratneDissanayakeSomaratneDissanayake是一名导演编剧，主要作品有《欲望》、《蝴蝶的翅膀》。外文名：SomaratneDissanayake职业：导演、编剧代表作品：《蝴蝶的翅膀》合作人物：SomaratneDissanayake

有没有听过关于Michael 说他一定不行（大体这个意思）我尝试反驳 但他们说他直就不会后面找洞钻（后门？）这是指 Michael是gay 在后面找洞钻

redis是内存数据库，访问速度非常快，所以能够解决的也都是这些缓存类型的问题，如下：1、会话缓存（Session Cache）最常用的一种使用Redis的情景是会话缓存（session cache）。用Redis缓存会话比其他存储（如Memcached）的优势在于：Redis提供持久化。当维护一个不是严格要求一致性的缓存时，如果用户的购物车信息全部丢失，大部分人都会不高兴的，现在，他们还会这样吗？幸运的是，随着 Redis 这些年的改进，很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。2、全页缓存（FPC）除基本的会话token之外，Redis还提供很简便的FPC平台。回到一致性问题，即使重启了Redis实例，因为有磁盘的持久化，用户也不会看到页面加载速度的下降，这是一个极大改进，类似PHP本地FPC。再次以Magento为例，Magento提供一个插件来使用Redis作为全页缓存后端。此外，对WordPress的用户来说，Pantheon有一个非常好的插件 wp-redis，这个插件能帮助你以最快速度加载你曾浏览过的页面。3、队列Reids在内存存储引擎领域的一大优点是提供 list 和 set 操作，这使得Redis能作为一个很好的消息队列平台来使用。Redis作为队列使用的操作，就类似于本地程序语言（如Python）对 list 的 push/pop 操作。

推荐的关于redis、dubbo、nocas的书：1.Redis设计与实现：Redis技术专家撰写，深入了解Redis技术内幕的之作。从源码角度解析Redis的架构设计、实现原理和工作机制，为高效使用 Redis 提供原理性指导；2.深入理解Apache Dubbo与实战：主要侧重于详细解读Dubbo框架工作原理和底层机制，并结合少量核心源码进行讲解。在原理的基础上，展示一些动手扩展Dubbo特性的实战场；3.Nacos架构&原理：Nacos 开源之前在阿里内部已经发展了十年，沉淀了很多优秀的能力，如其易用性、稳定性、实时性以及大规模的特性；也有很多历史负担，在开源的时候我们取其精华进行开源，为了提升代码的健壮性和扩展性，进行了充分的分层和模块化设计。

上一篇文章Redis主从复制原理中简要地说明了主从复制的一个基本原理，包含全量复制、复制积压缓冲区与增量复制等内容，有兴趣的同学可以先看下。 利用主从复制，可以实现读写分离、数据备份等功能。但如果主库宕机后，需要运维人员手动地将一个从库提升为新主库，并将其他从库slaveof新主库，以此来实现故障恢复。 因此， 主从模式的一个缺点，就在于无法实现自动化地故障恢复 。Redis后来引入了哨兵机制，哨兵机制大大提升了系统的高可用性。 哨兵，就是站岗放哨的，时刻监控周围的一举一动，在第一时间发现敌情并发出及时的警报。 Redis中的哨兵（Sentinel）， 则是一个特殊的Redis实例 ，不过它并不存储数据。也就是说，哨兵在启动时，不会去加载RDB文件。 关于Redis的持久化，可以参考我的另外一篇文章 谈谈Redis的持久化——AOF日志与RDB快照 上图就是一个典型的哨兵架构，由数据节点与哨兵节点构成，通常会部署多个哨兵节点。 哨兵主要具有三个作用， 监控、选主与通知 。 监控：哨兵会利用心跳机制，周期性不断地检测主库与从库的存活性 选主：哨兵检测到主库宕机后，选择一个从库将之切换为新主库 通知：哨兵会将新主库的地址通知到所有从库，使得所有从库与旧主库slaveof新主库，也会将新主库的地址通知到客户端上 我会在下文详细讲一下监控与选主的过程 哨兵系统是通过3个定时任务，来完成对主库、从库与哨兵之间的探活。 首先我们会在配置文件中配置主库地址，这样哨兵在启动后，会以 每隔10秒 的频率向主库发送info命令，从而获得当前的主从拓扑关系，这样就拿到了所有从库的地址。 接着 每隔2秒 ，会使用pub/sub（发布订阅）机制，在主库上的 sentinel :hello的频道上发布消息，消息内容包括哨兵自己的ip、port、runid与主库的配置。 每个哨兵都会订阅该频道，在该频道上发布与消费消息，从而实现哨兵之间的互相感知。 利用启动配置与info命令可以获取到主从库地址，利用发布订阅可以感知到其余的哨兵节点。 在此基础上，哨兵会 每隔1秒 向主库、从库与其他哨兵节点发送PING命令，因此来进行互相探活。 当某个哨兵在 **down-after-milliseconds（默认是30秒） **配置的连续时间内，仍然没有收到主库的正确响应，则当前哨兵会认为主库 主观下线 ，并将其标记为sdown（subjective down） 为了避免当前哨兵对主库的误判，因此这个时候还需要参考其他哨兵的意见。 接着当前哨兵会向其他哨兵发送 sentinel is-master-down-by-addr 命令， 如果有半数以上（由quorum参数决定）的哨兵认为主库确实处于主观下线状态，则当前哨兵认为主库客观下线 ，标记为odown（objective down） 一旦某个主库被认定为客观下线时，这个时候需要进行哨兵选举，选举出一个领导者哨兵，来完成主从切换的过程。 哨兵A在向其他哨兵发送 sentinel is-master-down-by-addr 命令时，同时要求其他哨兵同意将其设置为Leader，也就是想获得其他哨兵的投票。 在每一轮选举中，每个哨兵仅有一票。投票遵循先来先到的原则，如果某个哨兵没有投给别人，就会投给哨兵A。 首先获得半数以上投票的哨兵，将被选举称为Leader。 这里的哨兵选举，采用的是Raft算法。这里不对Raft做详细的探讨，有兴趣的同学，可以参考我的另外一篇文章 22张图，带你入门分布式一致性算法Raft 该文章采用大量的图例，相信你可以从中学习到全新的知识，从而打开分布式一致性算法的大门，大伙们记得等我搞完Paxos与Zab。 过半投票机制也常用于很多算法中，例如RedLock，在半数以上的节点上加锁成功，才代表申请到了分布式锁，具体可参考这篇文章的最后 我用了上万字，走了一遍Redis实现分布式锁的坎坷之路，从单机到主从再到多实例，原来会发生这么多的问题 在Zookeeper选举中，同样也用到了过半投票机制，在这篇文章中 面试官：能给我画个Zookeeper选举的图吗？ 我从源码角度分析了Zookeeper选举的过程。 在选举到领导者哨兵后，将由该哨兵完成故障恢复工作。 故障恢复分为以下两步： 详细说一下第一步，挑选是有条件的。首先要过滤出不健康的节点，再按某种规则排序，最后取第一个从库，我们直接从源码入手： 因此，以下从库会被过滤出： 剩下的节点，就是健康的节点，此时再执行一次快速排序，排序的规则如下： 本文算是Redis哨兵的一个入门文章，主要讲了哨兵的作用，例如监控、选主和通知。 在Redis读写分离的情况下，使用哨兵可以很轻松地做到故障恢复，提升了整体的可用性。 但哨兵无法解决Redis单机写的瓶颈，这就需要引入集群模式，相应的文章也被列为明年的写作计划中。 </article>

可以redis真的是一个很好的技术，它可以很好的在一定程度上解决网站一瞬间的并发量，例如商品抢购秒杀等活动。。。redis之所以能解决高并发的原因是它可以直接访问内存，而以往我们用的是数据库(硬盘),提高了访问效率,解决了数据库服务器压力。为什么redis的地位越来越高，我们为何不选择memcache，这是因为memcache只能存储字符串，而redis存储类型很丰富（例如有字符串、LIST、SET等），memcache每个值最大只能存储1M,存储资源非常有限,十分消耗内存资源,而redis可以存储1G,最重要的是memcache它不如redis安全,当服务器发生故障或者意外关机等情况时,redsi会把内存中的数据备份到硬盘中,而memcache所存储的东西全部丢失;这也说明了memcache不适合做数据库来用,可以用来做缓存。下面用redis解决瞬间秒杀活动来说明：下面这个程序模拟了20w人一瞬间涌入这个页面进行秒杀,能够秒杀成功的只有500人,我们把先进来的用户放入redis队列中,当队列中的用户达到500时，后来用户就转到秒杀结束页面。这里用随机数来表示不同的用户。这里我们可以看到秒杀成功的第一个用户的id是208522,秒杀成功的最后一个用户是176260,参与秒杀人数总共是20w。（让大家注意这些的原因是为了验证下面的准确性）。接下来我们依次从队列中把秒杀成功的500个用户取出来并观察第一个用户和最后一个用户是否跟之前的记录值一样我们可以看到从秒杀成功队列中依次取出的第一个用户id是208522，最后一个用户是176260，可以看出结果是很准确的。redis在解决高并发这方面的能力是真的挺不错的。

目前想到的原因有这几方面。Libevent。和Memcached不同，Redis并没有选择libevent。Libevent为了迎合通用性造成代码庞大(目前Redis代码还不到libevent的1/3)及牺牲了在特定平台的不少性能。Redis用libevent中两个文件修改实现了自己的epoll event loop(4)。业界不少开发者也建议Redis使用另外一个libevent高性能替代libev，但是作者还是坚持Redis应该小巧并去依赖的思路。一个印象深刻的细节是编译Redis之前并不需要执行./configure。CAS问题。CAS是Memcached中比较方便的一种防止竞争修改资源的方法。CAS实现需要为每个cache key设置一个隐藏的cas token，cas相当value版本号，每次set会token需要递增，因此带来CPU和内存的双重开销，虽然这些开销很小，但是到单机10G+ cache以及QPS上万之后这些开销就会给双方相对带来一些细微性能差别。单线程有时候比多线程 或多进程更快，比需要考虑并发、锁，也不会增加上下文切换等开销，也即代码更加简洁，执行效率更高～～～Redis是用内部是快的原因之一，要比较的化，可以同MemCache比较下。

有两种方法，一种方法使用mysql的check table和repair table 的sql语句，另一种方法是使用MySQL提供的多个myisamchk, isamchk数据检测恢复工具。前者使用起来比较简便。推荐使用。1. check table 和 repair table登陆mysql 终端：mysql -uxxxxx -p dbnamecheck table tabTest;如果出现的结果说Status是OK，则不用修复，如果有Error，可以用：repair table tabTest;进行修复，修复之后可以在用check table命令来进行检查。在新版本的phpMyAdmin里面也可以使用check/repair的功能。2. myisamchk, isamchk其中myisamchk适用于MYISAM类型的数据表，而isamchk适用于ISAM类型的数据表。这两条命令的主要参数相同，一般新的系统都使用MYISAM作为缺省的数据表类型，这里以myisamchk为例子进行说明。当发现某个数据表出现问题时可以使用：myisamchk tablename.MYI进行检测，如果需要修复的话，可以使用：myisamchk -of tablename.MYI关于myisamchk的详细参数说明，可以参见它的使用帮助。需要注意的时在进行修改时必须确保MySQL服务器没有访问这个数据表，保险的情况下是最好在进行检测时把MySQL服务器Shutdown掉。－－－－－－－－－－－－－－－－－－－－－－－－－－－－－另外可以把下面的命令放在你的rc.local里面启动MySQL服务器前：[ -x /tmp/mysql.sock ] && /pathtochk/myisamchk -of /DATA_DIR/*/*.MYI其中的/tmp/mysql.sock是MySQL监听的Sock文件位置，对于使用RPM安装的用户应该是/var/lib/mysql/mysql.sock，对于使用源码安装则是/tmp/mysql.sock可以根据自己的实际情况进行变更，而pathtochk则是myisamchk所在的位置，DATA_DIR是你的MySQL数据库存放的位置。需要注意的时，如果你打算把这条命令放在你的rc.local里面，必须确认在执行这条指令时MySQL服务器必须没有启动！检测修复所有数据库(表)

1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。3. Redis支持数据的备份，即master-slave模式的数据备份。4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。Redis在很多方面具备数据库的特征，或者说就是一个数据库系统，而Memcached只是简单的K/V缓存

redis、memcahce 比较相似，但与 mongodb 完全不同，几乎没有可比性。总的来说 redis/memcache 是基于内存的，讲究的是性能，多用作缓存层，比如说存放session。而 mongodb 是面向文档的，存储的是类似JSON的非结构化数据，查询起来非常方便，开发效率高，比较类似传统SQL关系型数据库。从以下几个维度，对redis、memcache、mongoDB 做了对比：体积Redis是一个基于内存的键值数据库，它由C语言实现的，以单线程异步的方式工作，与Nginx/ NodeJS工作原理近似。所以文件非常小。编绎出来的主文件还不到 2Mb，在 Linux 服务器上初始只需要占用1Mb左右的内存。Mongodb安装包则要大的多，跟mySQL差不多，都是百兆级的。性能都比较高，性能对我们来说应该都不是瓶颈总体来讲，TPS方面redis和memcache差不多，要大于mongodb操作的便利性memcache数据结构单一redis丰富一些，数据操作方面，redis更好一些，较少的网络IO次数mongodb支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富推荐学习《python教程》内存空间的大小和数据量的大小redis在2.0版本后增加了自己的VM特性，突破物理内存的限制；可以对key value设置过期时间（类似memcache）memcache可以修改最大可用内存,采用LRU算法mongoDB适合大数据量的存储，依赖操作系统VM做内存管理，吃内存也比较厉害，服务不要和别的服务在一起可用性（单点问题）对于单点问题，redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整个快照,无增量复制，因性能和效率问题，所以单点问题比较复杂；不支持自动sharding,需要依赖程序设定一致hash 机制。一种替代方案是，不用redis本身的复制机制，采用自己做主动复制（多份存储），或者改成增量复制的方式（需要自己实现），一致性问题和性能的权衡Memcache本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的hash或者环状的算法，解决单点故障引起的抖动问题。mongoDB支持master-slave,replicaset（内部采用paxos选举算法，自动故障恢复）,auto sharding机制，对客户端屏蔽了故障转移和切分机制。可靠性（持久化）对于数据持久化和数据恢复，redis支持（快照、AOF）：依赖快照进行持久化，aof增强了可靠性的同时，对性能有所影响memcache不支持，通常用在做缓存,提升性能；MongoDB从1.8版本开始采用binlog方式支持持久化的可靠性，备份还原方法7.数据一致性（事务支持）Memcache 在并发场景下，用cas保证一致性redis事务支持比较弱，只能保证事务中的每个操作连续执行mongoDB不支持事务8.数据分析mongoDB内置了数据分析的功能(mapreduce),其他不支持9.应用场景redis：数据量较小的更性能操作和运算上memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写少，对于数据量比较大，可以采用sharding）MongoDB:主要解决海量数据的访问效率问题。

1、性能都比较高，性能对我们来说应该都不是瓶颈总体来讲，TPS方面redis和memcache差不多2、操作的便利性memcache数据结构单一redis丰富一些，数据操作方面，redis更好一些，较少的网络IO次数3、内存空间的大小和数据量的大小redis在2.0版本后增加了自己的VM特性，突破物理内存的限制；可以对key value设置过期时间（类似memcache）memcache可以修改最大可用内存,采用LRU算法4、可用性（单点问题）对于单点问题，redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整个快照,无增量复制，因性能和效率问题，所以单点问题比较复杂；不支持自动sharding,需要依赖程序设定一致hash 机制。一种替代方案是，不用redis本身的复制机制，采用自己做主动复制（多份存储），或者改成增量复制的方式（需要自己实现），一致性问题和性能的权衡Memcache本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的hash或者环状的算法，解决单点故障引起的抖动问题。5、可靠性（持久化）对于数据持久化和数据恢复，redis支持（快照、AOF）：依赖快照进行持久化，aof增强了可靠性的同时，对性能有所影响memcache不支持，通常用在做缓存,提升性能；6、数据一致性（事务支持）Memcache 在并发场景下，用cas保证一致性redis事务支持比较弱，只能保证事务中的每个操作连续执行7、数据分析不支持8、应用场景redis：数据量较小的更性能操作和运算上memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写少，对于数据量比较大，可以采用sharding）

简要说明2018年十月 Redis 发布了稳定版本的 5.0 版本，推出了各种新特性，其中一点是放弃 Ruby的集群方式，改为 使用 C语言编写的 redis-cli的方式，是集群的构建方式复杂度大大降低。关于集群的更新可以在 Redis5 的版本说明中看到，如下：The cluster manager was ported from Ruby (redis-trib.rb) to C code inside redis-cli. check `redis-cli --cluster help ` for more info.可以查看Redis官网查看集群搭建方式，连接如下https://redis.io/topics/cluster-tutorial以下步骤是在一台 Linux 服务器上搭建有6个节点的 Redis集群。操作步骤创建目录新建目录：/root/software/redis下载源码并解压编译wget http://download.redis.io/releases/redis-5.0.0.tar.gztar xzf redis-5.0.0.tar.gzcd redis-5.0.0make创建6个Redis配置文件6个配置文件不能在同一个目录，此处我们定义如下：/root/software/redis/redis-cluster-conf/7001/redis.conf/root/software/redis/redis-cluster-conf/7002/redis.conf/root/software/redis/redis-cluster-conf/7003/redis.conf/root/software/redis/redis-cluster-conf/7004/redis.conf/root/software/redis/redis-cluster-conf/7005/redis.conf/root/software/redis/redis-cluster-conf/7006/redis.conf配置文件的内容为：port 7001 #端口cluster-enabled yes #启用集群模式cluster-config-file nodes.confcluster-node-timeout 5000 #超时时间appendonly yesdaemonize yes #后台运行protected-mode no #非保护模式pidfile /var/run/redis_7001.pid其中 port 和 pidfile 需要随着 文件夹的不同调增启动节点/root/software/redis/redis-5.0.0/src/redis-server /root/software/redis/redis-cluster-conf/7001/redis.conf/root/software/redis/redis-5.0.0/src/redis-server /root/software/redis/redis-cluster-conf/7002/redis.conf/root/software/redis/redis-5.0.0/src/redis-server /root/software/redis/redis-cluster-conf/7003/redis.conf/root/software/redis/redis-5.0.0/src/redis-server /root/software/redis/redis-cluster-conf/7004/redis.conf/root/software/redis/redis-5.0.0/src/redis-server /root/software/redis/redis-cluster-conf/7005/redis.conf/root/software/redis/redis-5.0.0/src/redis-server /root/software/redis/redis-cluster-conf/7006/redis.conf启动集群/root/software/redis/redis-5.0.0/src/redis-cli --cluster create 192.168.2.40:7001 192.168.2.40:7002 192.168.2.40:7003 192.168.2.40:7004 192.168.2.40:7005 192.168.2.40:7006 --cluster-replicas 1启动后，可看到成功信息，如下：>>> Performing hash slots allocation on 6 nodes...Master[0] -> Slots 0 - 5460Master[1] -> Slots 5461 - 10922Master[2] -> Slots 10923 - 16383Adding replica 192.168.2.40:7004 to 192.168.2.40:7001Adding replica 192.168.2.40:7005 to 192.168.2.40:7002Adding replica 192.168.2.40:7006 to 192.168.2.40:7003>>> Trying to optimize slaves allocation for anti-affinity[WARNING] Some slaves are in the same host as their masterM: 191c645200a8b4d267f71e3354c8248dbb533dde 192.168.2.40:7001 slots:[0-5460] (5461 slots) masterM: 400a08d4e5a534c1b609988105d3e045395fbd12 192.168.2.40:7002 slots:[5461-10922] (5462 slots) masterM: 684f6aa0fbccda295ce6818a8c01ee7255a7b002 192.168.2.40:7003 slots:[10923-16383] (5461 slots) masterS: f2701549ae98315b432d73b49d139ee77d5685b4 192.168.2.40:7004 replicates 684f6aa0fbccda295ce6818a8c01ee7255a7b002S: 9fdc1e375436767ab815cbddd3df674f3bc2ca99 192.168.2.40:7005 replicates 191c645200a8b4d267f71e3354c8248dbb533ddeS: e7742888ed85b37cff4a98e861e99bb16e8bae2c 192.168.2.40:7006 replicates 400a08d4e5a534c1b609988105d3e045395fbd12Can I set the above configuration? (type "yes" to accept): yes>>> Nodes configuration updated>>> Assign a different config epoch to each node>>> Sending CLUSTER MEET messages to join the clusterWaiting for the cluster to join....>>> Performing Cluster Check (using node 192.168.2.40:7001)M: 191c645200a8b4d267f71e3354c8248dbb533dde 192.168.2.40:7001 slots:[0-5460] (5461 slots) master 1 additional replica(s)M: 684f6aa0fbccda295ce6818a8c01ee7255a7b002 192.168.2.40:7003 slots:[10923-16383] (5461 slots) master 1 additional replica(s)S: 9fdc1e375436767ab815cbddd3df674f3bc2ca99 192.168.2.40:7005 slots: (0 slots) slave replicates 191c645200a8b4d267f71e3354c8248dbb533ddeS: e7742888ed85b37cff4a98e861e99bb16e8bae2c 192.168.2.40:7006 slots: (0 slots) slave replicates 400a08d4e5a534c1b609988105d3e045395fbd12M: 400a08d4e5a534c1b609988105d3e045395fbd12 192.168.2.40:7002 slots:[5461-10922] (5462 slots) master 1 additional replica(s)S: f2701549ae98315b432d73b49d139ee77d5685b4 192.168.2.40:7004 slots: (0 slots) slave replicates 684f6aa0fbccda295ce6818a8c01ee7255a7b002[OK] All nodes agree about slots configuration.>>> Check for open slots...>>> Check slots coverage...[OK] All 16384 slots covered.至此，Reids集群搭建完成。

有 slots 无 slots 时直接删除 （5）学习redis-trib命令使用： 添加两个节点 docker-compose.yaml 添加 1 create ：创建一个集群环境host1:port1 ... hostN:portN（集群中的主从节点比例） 2 call ：可以执行redis命令 3 add-node ：将一个节点添加到集群里，第一个参数为新节点的ip:port，第二个参数为集群中任意一个已经存在的节点的ip:port 4 del-node [host:port node_id] ：移除一个节点 5 reshard ：重新分片 6 check [hosts:port]：检查集群状态 步骤一：使用add-node命令：绿色为新增节点，红色为已知存在节点 输出如下： 步骤二：查看集群状态： 注意： 当添加节点成功以后，新增的节点不会有任何数据，因为它没有分配任何的slot（hash槽）。我们需要为新节点手工分配slot。 步骤一：使用redis-trib命令，找到集群中的任意一个主节点（红色位置表现集群中的任意一个主节点），对其进行重新分片工作。 输出如下： 1提示一：是希望你需要多少个槽移动到新的节点上，可以自己设置，比如200个槽。 2提示二：是你需要把这200个slot槽移动到那个节点上去（需要指定节点id），并且下个 提示是输入all为从所有主节点（7001 7002 7003）中分别抽取响应的槽数（一共为200个槽到指定的新节点中！，并且会打印执行分片的计划。） 3提示三：输入yes确认开始执行分片任务。在最后我们再次看一下集群状态： 如上图所示，现在我们的7007已经有slot槽了，也就是说可以在7007上进行读写数据啦！到此为止我们的7007已经加入到集群中啦，并且是主节点（Master） 步骤一：还是需要执行add-node命令： 提示添加成功后我们继续看一下集群的状态： 如图所示，还是一个master节点，没有被分配任何的slot槽。 步骤二：我们需要执行replicate命令来指定当前节点（从节点）的主节点id为哪个。 首先需要登录新加的7008节点的客户端，然后使用集群命令进行操作，把当前的7008（slave）节点指定到一个主节点下（这里使用之前创建的7007主节点，红色表示节点id） 我们继续看一下当前集群的状态，如下图：我们已经成功的把7008放到7007这个主节点下面了，到此为止我们已经成功的添加完一个从节点了。 （9）我们可以对集群进行操作，来验证下是否可以进行读写（当然可以）。 （10）我们现在尝试删除一个节点（7008 slave） 步骤一：删除从节点7008，输入del-node命令，指定删除节点ip和端口，以及节点id（红色为7008节点id） 输出如下： 步骤二：再次查看一下集群状态，如下图所示，我们已经成功的移除了7008 slave节点，另外我们发现移除一个节点以后，当前节点的服务进程也会随之销毁。可以使用ps命令查看当前的服务（ps -el | grep redis），发现少了一个运行的server，也就是刚移除的7008从节点。 （11）最后，我们尝试删除之前加入的主节点7007，这个步骤会相对比较麻烦一些，因为主节点的里面是有分配了slot槽的，所以我们这里必须先把7007里的slot槽放入到其他的可用主节点中去，然后再进行移除节点操作才行，不然会出现数据丢失问题。 步骤一：删除7007（master）节点之前，我们需要先把其全部的数据（slot槽）移动到其他节点上去（目前只能把master的数据迁移到一个节点上，暂时做不了平均分配功能）。 输出如下： 到此为止我们已经成功的把7007主节点的数据迁移到7001上去了，我们可以看一下现在的集群状态如下图，你会发现7007下面已经没有任何数据（slot）槽了，证明迁移成功！ 输出如下： 最后：我们查看集群状态，一切还原为最初始状态啦！OK 结束！

转自 https://blog.csdn.net/chenxuegui1234/article/details/100171599 现在redis集群架构，redis cluster用的会比较多。 如下图所示 对于客户端请求的key，根据公式HASH_SLOT=CRC16(key) mod 16384，计算出映射到哪个分片上，然后Redis会去相应的节点进行操作！ 那大家思考过，为什么有16384个槽么? ps:CRC16算法产生的hash值有16bit，该算法可以产生2^16-=65536个值。换句话说，值是分布在0~65535之间。那作者在做mod运算的时候，为什么不mod65536，而选择mod16384？ 其实我当初第一次思考这个问题的时候，我心里是这么想的，作者应该是觉得16384就够了，然后我就开始查这方面资料。 很幸运的是，这个问题，作者是给出了回答的！ 地址如下: https://github.com/antirez/redis/issues/2576 作者原版回答如下: The reason is: So 16k was in the right range to ensure enough slots per master with a max of 1000 maters, but a small enough number to propagate the slot configuration as a raw bitmap easily. Note that in small clusters the bitmap would be hard to compress because when N is small the bitmap would have slots/N bits set that is a large percentage of bits set. 因此，能看懂上面那段话的读者。这篇文章不用看了，因为作者讲的很清楚了。本文只是对上面那段话做一些解释而已。 我们回忆一下Redis Cluster的工作原理！ 这里要先将节点握手讲清楚。我们让两个redis节点之间进行通信的时候，需要在客户端执行下面一个命令 <pre style="box-sizing: border-box; outline: 0px; margin: 0px 0px 24px; padding: 8px; font-weight: 400; position: relative; white-space: pre-wrap; overflow-wrap: break-word; overflow-x: auto; font-family: Consolas, Inconsolata, Courier, monospace; font-size: 14px; line-height: 22px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(255, 255, 255); text-decoration-style: initial; text-decoration-color: initial;">127.0.0.1:7000>cluster meet 127.0.0.1:7001 </pre> 如下图所示 意思很简单，让7000节点和7001节点知道彼此存在！ 在握手成功后，两个节点之间会 定期 发送ping/pong消息，交换 数据信息 ，如下图所示。 在这里，我们需要关注三个重点。 到底在交换什么数据信息？ 交换的数据信息，由消息体和消息头组成。 消息体无外乎是一些节点标识啊，IP啊，端口号啊，发送时间啊。这与本文关系不是太大，我不细说。 我们来看消息头，结构如下 注意看红框的内容，type表示消息类型。 另外，消息头里面有个myslots的char数组，长度为16383/8，这其实是一个bitmap,每一个位代表一个槽，如果该位为1，表示这个槽是属于这个节点的。 到底数据信息究竟多大？ 在消息头中，最占空间的是myslots[CLUSTER_SLOTS/8]。这块的大小是: 16384÷8÷1024=2kb 那在消息体中，会携带一定数量的其他节点信息用于交换。 那这个其他节点的信息，到底是几个节点的信息呢？ 约为集群总节点数量的1/10，至少携带3个节点的信息。 这里的重点是: 节点数量越多，消息体内容越大。 消息体大小是10个节点的状态信息约1kb。 那定期的频率是什么样的？ redis集群内节点，每秒都在发ping消息。规律如下 因此，每秒单节点发出ping消息数量为 1+10*num（node.pong_received>cluster_node_timeout/2） 那大致带宽损耗如下所示，图片来自《Redis开发与运维》 讲完基础知识以后，我们可以来看作者的回答了。 (1)如果槽位为65536，发送心跳信息的消息头达8k，发送的心跳包过于庞大。 如上所述，在消息头中，最占空间的是myslots[CLUSTER_SLOTS/8]。 当槽位为65536时，这块的大小是: 65536÷8÷1024=8kb 因为每秒钟，redis节点需要发送一定数量的ping消息作为心跳包，如果槽位为65536，这个ping消息的消息头太大了，浪费带宽。 (2)redis的集群主节点数量基本不可能超过1000个。 如上所述，集群节点越多，心跳包的消息体内携带的数据越多。如果节点过1000个，也会导致网络拥堵。因此redis作者，不建议redis cluster节点数量超过1000个。 那么，对于节点数在1000以内的redis cluster集群，16384个槽位够用了。没有必要拓展到65536个。 (3)槽位越小，节点少的情况下，压缩率高 Redis主节点的配置信息中，它所负责的哈希槽是通过一张bitmap的形式来保存的，在传输过程中，会对bitmap进行压缩，但是如果bitmap的填充率slots / N很高的话(N表示节点数)，bitmap的压缩率就很低。 如果节点数很少，而哈希槽数量很多的话，bitmap的压缩率就很低。 ps：文件压缩率指的是，文件压缩前后的大小比。 综上所述，作者决定取16384个槽，不多不少，刚刚好！

Volvo is a swedish car make. 沃尔沃是瑞典的汽车品牌。

缓存技术可以用来减轻数据库的压力，提升访问效率。目前在企业项目中对缓存也是越来越重视。但是缓存不是说随随便便加入项目就可以了。将缓存整合到项目中，这才是第一步。而缓存带来的穿透问题，进而导致的雪蹦问题都是我们迫切需要解决的问题。本篇文章将我平时项目中的解决方案分享给大家，以供参考。一、缓存穿透的原理缓存的正常使用如图：如图所示，缓存的使用流程：1、先从缓存中取数据，如果能取到，则直接返回数据给用户。这样不用访问数据库，减轻数据库的压力。2、如果缓存中没有数据，就会访问数据库。这里面就会存在一个BUG，如图：如图，缓存就像是数据库的一道防火墙，将请求比较频繁的数据放到缓存中，从而减轻数据库的压力。 但是如果有人恶意攻击，那就很轻松的穿透你的缓存，将所有的压力都给数据库。比如上图，你缓存的key都是正整数，但是我偏偏使用负数作为key访问你的缓存，这样就会导致穿透缓存，将压力直接给数据库。二、导致缓存穿透的原因缓存穿透的问题，肯定是再大并发情况下。依此为前提，我们分析缓存穿透的原因如下：1、恶意攻击，猜测你的key命名方式，然后估计使用一个你缓存中不会有的key进行访问。2、第一次数据访问，这时缓存中还没有数据，则并发场景下，所有的请求都会压到数据库。3、数据库的数据也是空，这样即使访问了数据库，也是获取不到数据，那么缓存中肯定也没有对应的数据。这样也会导致穿透。三、解决缓存穿透缓存穿透在于一步步规避穿透的原因，如图：如上图所示，解决的步骤如下：1、再web服务器启动时，提前将有可能被频繁并发访问的数据写入缓存。—这样就规避大量的请求在第3步出现排队阻塞。2、规范key的命名，并且统一缓存查询和写入的入口。这样，在入口处，对key的规范进行检测。_这样保存恶意的key被拦截。3、Synchronized双重检测机制，这时我们就需要使用同步（Synchronized）机制，在同步代码块前查询一下缓存是否存在对应的key，然后同步代码块里面再次查询缓存里是否有要查询的key。 这样“双重检测”的目的，还是避免并发场景下导致的没有意义的数据库的访问（也是一种严格避免穿透的方案）。这一步会导致排队，但是第一步中我们说过，为了避免大量的排队，可以提前将可以预知的大量请求提前写入缓存。4、不管数据库中是否有数据，都在缓存中保存对应的key，值为空就行。_这样是为了避免数据库中没有这个数据，导致的平凡穿透缓存对数据库进行访问。5、第4步中的空值如果太多，也会导致内存耗尽。导致不必要的内存消耗。这样就要定期的清理空值的key。避免内存被恶意占满。导致正常的功能不能缓存数据。更多Redis相关技术文章，请访问Redis教程栏目进行学习！

Redis-Shake【一】简要介绍 Redis-Shake【二】 Sync功能实现简介 Redis-shake是一个基于golang语言开发的，用于在两个redis之间同步数据的工具，满足用户非常灵活的同步、迁移需求。 github地址 https://github.com/alibaba/RedisShake 支持redis standalone、cluster、sentinel、proxies（如：Codis、twemproxy、Aliyun Cluster Proxy, Tencent Cloud Proxy 等）之间的数据迁移， redis版本支持2.x to 5.0 decode : 把Redis RDB文件解析成人类可读的文件格式. restore : 把Rdis RDB文件作为数据源，恢复到目标Redis实例中. dump : 对源Redis实例中的数据dump到RDB文件中. sync : 基于Redis sync/psync命令从源redis实例同步到目标Redis实例，该模式包含全量同步和增量同步两个阶段。（通过默认Redis Slave来实现） rump : 基于Redis scan命令的方式从源Redis同步到目标Redis实例。只支持全量同步，这种方式通常适用于源redis不支持sync/psync命令的场景 可以参考官网 https://github.com/alibaba/RedisShake/wiki/%E7%AC%AC%E4%B8%80%E6%AC%A1%E4%BD%BF%E7%94%A8%EF%BC%8C%E5%A6%82%E4%BD%95%E8%BF%9B%E8%A1%8C%E9%85%8D%E7%BD%AE%EF%BC%9F 启动命令： redis-shake --conf={配置文件地址} --type={模式：sync/dump等} 模式需要与配置文件中的source target对应。如下是一个sync模式的配置文件示例： 下一节 介绍一下Redis-Shake Sync的实现原理

redis 貌似没有提供一个可靠的方法获得每个 db 的实际占用，这主要是因为 redis 本身就没有 db 文件概念，所有 db 都是混在一个 rdb 文件里面的。 要想估算 db 的大小，需要通过 keys * 遍历 db 里所有的 key，然后用 debug object <key> 来获得 key 的内存占用，serializedlength 就是占用内存的字段长度。 根据 RDB 格式文档，可以估算出每个 key 的实际占用为： key_size = strlen(key) + serializedlength + 7 不过这个估算极不靠谱，因为 redis 可能将 key 做压缩，此时估算出来的值可能偏大。 下面的命令可以查看 db0 的大小（key 个数），其他的以此类推。 select 0 dbsize 或者使用 info keyspace 同时得到所有 db 信息。

首先指出 时间复杂度的表示是大写的 欧 而不是 零 ， 也就是说是O 不是0；其次理解的话，可以简单从字面层次理解为 运算该redis函数所需要的时间来表示该函数的复杂程度 。 具体理解的话 你可以看 RESTORE 函数 RESTORE key ttl serialized-value！

突然发现我们的redis 已经用了30G了，好吧这是个很尴尬的数字因为我们的缓存机器的内存目前是32G的，内存已经告竭。幸好上上周公司采购了90G的机器，现在已经零时迁移到其中的一台机器上了。(跑题下，90G的内存太爽了是我除了koding.com 之外第二次用到90G的 突然发现我们的redis 已经用了30G了，好吧这是个很尴尬的数字因为我们的缓存机器的内存目前是32G的，内存已经告竭。幸好上上周公司采购了90G的机器，现在已经零时迁移到其中的一台机器上了。(跑题下，90G的内存太爽了是我除了koding.com 之外第二次用到90G的机器，koding 是个好网站，在线编程IDE。) 但是随着数据量越来越大单机始终无法承受的，改造势在必行。经过初步思考我们得出了很简单的方案 概括起来就是 "内外兼修"1.内功修炼先从我们的应用层说起 看看redis 使用情况 ，有没有办法回收一些key ，先进入redis 服务器执行 info ,有删减 1: redis 127.0.0.1:6391> info 2: used_memory_human:35.58G 3: keyspace_hits:2580207188 4: db0:keys=2706740,expires=1440700目前我们只使用了1个DB 但是key 太多了 有270W个key,已经过期的有144W。第一个想到的就是我勒个去,怎么会有这么多key ,第二个想法就是可能存在过大的key看看能不能针对过大的key 做优化？可是遗憾的是官方并没有命令显示db 的key 大小，我们只能自己想办法了Google 一番，发现国外友人已经写好了shell传送门: https://gist.github.com/epicserve/5699837可以列出每个key 大小了。可是这并不适用我们，因为我们key 太大了 执行了9个小时都没跑完，无力吐槽了。 其实还有一个选择就是用另外一个工具传送门:https://github.com/sripathikrishnan/redis-rdb-tools可惜这个太重了 ，不想麻烦ops ，我们就只能撩起袖子，造轮子。把shell 代码简单看了下发件DEBUG OBJECT 是个好东西啊 ，google 下发现官网 已经有简单的调试信息了，剩下的就好处理了 1: #coding=utf-8 2: import redis 3: 4: COLOR_RED = "33[31;49;1m %s 33[31;49;0m" 5: 6: COLOR_GREED = "33[32;49;1m %s 33[39;49;0m" 7: 8: COLOR_YELLOW = "33[33;49;1m %s 33[33;49;0m" 9: 10: COLOR_BLUE = "33[34;49;1m %s 33[34;49;0m" 11: 12: COLOR_PINK = "33[35;49;1m %s 33[35;49;0m" 13: 14: COLOR_GREENBLUE = "33[36;49;1m %s 33[36;49;0m" 15: 16: 17: def getHumanSize(value): 18:gb = 1024 * 1024 * 1024.0 19:mb = 1024 * 1024.0 20:kb = 1024.0>= gb: 22:return COLOR_RED % (str(round(value / gb, 2)) + " gb") 23:elif value >= mb: 24:return COLOR_YELLOW % (str(round(value / mb, 2)) + " mb") 25:elif value >= kb: 26:return COLOR_BLUE % (str(round(value / kb, 2)) + " kb") 27:else: 28:return COLOR_GREED % (str(value) + "b") 29: 30: 31: month = 3600 * 24 * 30 32: result = [] 33: client = redis.Redis(host="XXXXX", port=XXXX) 36: client.info() 37: 38: count = 0 39: for key in client.keys("*"): 40:try: 41:count += 1 42:idleTime = client.object("idletime", key) 43:refcount = client.object("refcount", key) 44:length = client.debug_object(key)["serializedlength"] 45:value = idleTime * refcount 46:print "%s key :%s , idletime : %s,refcount :%s, length : %s , humSize :%s" % (count, key, idleTime, refcount, length, getHumanSize(length)) 47:except Exception: 48:pass写了个简单的python 脚本输出每个key 的大小和idle time,和refer count 。有了这么多数据结合awk 就可以很好的统计每个key 的使用情况。有一点要注意的是这个size 是key 在redis 中的大小，并非实际的大小，这个是经过redis 压缩的。经过分析之后发现不存在过大的key ,但是存在有些key 半年都没有被访问过 Orz 。接下来就很好处理了,我们为每个key 设置的过期时间,若key 被hit 上则更新这个expire time 。这样可以逐步淘汰冷数据，达到冷热分离2. 外功修炼我们对内清理了无效的key，对外我们要做到水平扩展，单机的承载始终有限，于是我们开始了传说中的分布式改造分布式这东西看起来很唬人做起来更唬人，幸好我们是缓存服务 CAP约束有限。 缓存服务做分布式最好的当然是一致性hash 咯。其实当我们改造完成之后，才发现官方已经准备做这个分布式的缓存体系了（流口水啊） 只是现在还在开发中 给了个备用的响当当的 Twemproxy 奈何我们已经做好了，就先用着，坐等官方测试之后再说传送门： 我们实现了数据的平滑迁移，而且对server 的修改实现了最小影响。 因为原来是用的是phpredis 所以就扩展了下，代码可以平滑过渡。我们自己的实现：https://github.com/trigged/redis_con_hash其实扯了这么多就是要把redis 的数据分散开，单机的承载始终是个瓶颈，但是redis 在这方面没有Memcached 完善，不过以后会越来越好，

如果 MySQL 数据库比较大的话，我们很容易就能查出是哪些表占用的空间；不过如果 Redis 内存比较大的话，我们就不太容易查出是哪如果 MySQL 数据库比较大的话，我们很容易就能查出是哪些表占用的空间；不过如果 Redis 内存比较大的话，我们就不太容易查出是哪些（种）键占用的空间了。 有一些工具能够提供必要的帮助，比如 redis-rdb-tools 可以直接分析 RDB 文件来生成报告，可惜它不能百分百实现我的需求，而我也不想在它的基础上二次开发。实际上开发一个专用工具非常简单，利用 SCAN 和 DEBUG 等命令，没多少行代码就能实现：当然，前提是你需要提前总结出可能的键模式，，简单但不严谨的方法是 MONITOR：shell> /path/to/redis-cli monitor |awk -F """ "$2 ~ "ADD|SET|STORE|PUSH" {print $4}"此外，需要注意的是：因为 DEBUG 返回的 serializedlength 是序列化后的长度，所以最终计算的值小于实际内存占用，但考虑到相对大小依然是有参考意义的。Ubuntu 14.04下Redis安装及简单测试 Redis集群明细文档 Ubuntu 12.10下安装Redis（图文详解）+ Jedis连接Redis Redis系列-安装部署维护篇 CentOS 6.3安装Redis Redis安装部署学习笔记 Redis配置文件redis.conf 详解 Redis 的详细介绍：请点这里 Redis 的下载地址：请点这里本文永久更新链接地址：

1 是常数级 n是线性及 你就想象增长方式

在完成事件接入的需求时，我们需要记录上一个批次拉取的事件，并与当前拉取到的事件做出比对，从而进行差分。我们目前的做法是使用redis来进行缓存:将上一个批次拉取到的事件缓存到一个list中。但是当事件数量过多时，value的大小会超过1M的限制，直接抛出异常。这其实是Tair出于性能的考虑而做出的限制，本文将谈谈我个人对于bigKey的理解。 顾名思义，bigKey指一个key对应的value占据的内存空间相对比较大，bigKey通常会有两种表现形式: bigKey一旦产生，将会对tair的性能以及稳定性造成较大的影响，下面我将详细介绍一下bigKey的危害。 bigKey给tair带来的危害是多方面的，性能下降只是其中的一方面，极端情况下，bigKey甚至会导致缓存服务崩溃。下面我将从几个角度进行分析。我们可以看到: 另外，在Redis执行异步重写操作时(bgrewriteaof)，主线程会fork出一个子进程来执行重写命令，这个子进程会与主线程共享内存。当主线程收到了新增或者修改一个key的命令，主线程会申请一块额外的内存空间来保存数据。但如果这个key是一个bigKey时，主线程会去申请一块更大空间，同样会阻塞主线程(与JVM分配内存一样，涉及锁和同步)。如果申请不到足够的空间，会导致Swap甚至会有OOM的风险，这同样会降低Redis的性能和稳定性。 Tair中一个key最大为1M，我们就以1M举例，当访问这个key的QPS为1000时，每秒将会有1GB左右的流量，对于带宽来说将是一个较大压力。如果这个bigKey是一个热点key时，后果将不堪设想。 如果主从同步的 client-output-buffer-limit 设置过小，并且 master 存在大量bigKey(数据量很大)，主从全量同步时可能会导致 buffer 溢出，溢出后主从全量同步就会失败。如果主从集群配置了哨兵，那么哨兵会让 slave 继续向 master 发起全量同步请求，然后 buffer 又溢出同步失败，如此反复，会形成复制风暴，这会浪费 master 大量的 CPU、内存、带宽资源，也会让 master 产生阻塞的风险。 另外，当我们使用Redis Cluster时，由于Redis Cluster采用了同步迁移的方式，bigKey同样会阻塞主线程。这里提一下Codis，Codis在迁移bigKey时，使用了异步迁移 + 指令拆分的方式，对于bigKey (集合类型) 中每个元素，用一条指令进行迁移，而不是把整个 bigKey 进行序列化后再整体传输。这种化整为零的方式，就避免了 bigKey 迁移时，因为要序列化大量数据而阻塞的问题。当我们写入或者读取大量bigKey的时候，很有可能导致输入/输出缓冲区溢出。如果客户端占用的内存总量超过了服务器设置的maxmemory时(默认4GB)，将会直接触发服务器的内存淘汰策略，如果有数据被淘汰，再要获取这些数据就需要到后端回源，间接降低了缓存系统的性能。同时，淘汰的如果是bigKey也同样会阻塞主线程。另外，在极端情况下，多个客户端占用了过多的内存将导致OOM，进而使得整个redis进程崩溃。 使用切片集群的时候，我们通常会将不同的key存放在不同的实例上，如果存在bigKey的话，会导致相应实例的数据量增大，内存压力也相应增大。 常用的做法是通过./redis-cli --bigkeys命令对整个redis中的键值对进行统计，输出每种数据类型中最大的 bigkey 的信息。一般会配合-i参数一起使用,控制扫描间隔，避免长时间扫描降低 Redis 实例的性能。另外该命令不要在业务高峰期使用。 或者我们可以通过debug object key 命令去查看serializedlength属性，serializedlength表示key对应的value序列化后的字节数，通过观察serializedlength的大小可以辅助排查bigKey。使用scan + debug object key命令，我们可以计算其中每个key的serializedlength，进而发现其中的bigKey，并做好相应的监控和处理。不过对于集合类型的bigKey，debug object key 命令的执行效率不高，存在阻塞redis的风险。另外，在读取bigKey的时候，我们尽量不要一次性将全部数据读取出来，而是采用分批的方式进行读取:利用scan命令进行渐进式遍历，将大量数据分批多次读取出来，减小redis的压力，避免阻塞的风险。 同样的，在删除bigKey的时候我们也可以使用scan命令来进行批量删除。如果你是用的redis是4.0之后的版本，则可以利用unlink命令配合lazy free配置(需要手动开启)来进行异步删除，避免主线程阻塞。

最近在看 redis 这方面的知识，发现在 redis5 中产生了一种新的数据类型 Stream ，它和 kafka 的设计有些类似，可以当作一个简单的消息队列来使用。 解释： xadd 命令 返回的是数据的id, xx-yy (xx指的是毫秒数,yy指的是在这个毫秒内的第几条消息) 指定指定Stream的大小比模糊指定Stream的大小会稍微多少消耗一些性能。 ~ 模糊指定流的大小，可以看到指定的是1，实际上已经到了3. 使用redis的事务操作，获取到同一毫秒产生的多条数据，时间戳一样，序列号不一样 -: 表示最小id的值 +: 表示最大id的值 (: 表示开区间 直接写 毫秒 不写后面的序列号即可。 start 和 end 的值写的一样即可获取单挑数据。 使用 count 进行限制 使用方式和 XRANGE 类似，略。 需求： 往Stream中加入3条消息，然后删除第2条消息 注意： 需要注意的是，我们从Stream中删除一个消息，这个消息并不是被真正的删除了，而是被 标记为删除 ，这个时候这个消息还是占据着内容空间的。如果所有Stream中所有的消息都被标记删除，这个时候才会回收内存空间。但是这个Stream并不会被删除。 查看Stream中元素的长度 注意： 如果 xlen 后方的 key 不存在则返回0，否则返回元素的个数。 上方的意思是，保留 stream-key 这个Stream中最后的2个消息。 minid 是删除比这个id小的数据，本地测试的时候 没有测试出来 ，略。 XREAD 只是读取消息，读取完之后并不会删除消息。 使用 XREAD 读取消息，是完全独立与消费者组的，多个客户端可以同时读取消息。 count 限制单次读取最后的消息，因为当前读取可能没有这么多。 即读取队列尾的下一个消息，在非阻塞模式下始终是 nil 注意： 1、创建Stream的名称是 stream-key 2、创建2个消息，aa和bb $ 表示从最后一个元素消费，不包括Stream中的最后一个元素，即消费最新的消息。 1636362619125-0 某个消息的具体的ID,这个 g3 消费者组中的消息都是 大于> 这个id的消息。 也可以通过 xautoclaim 来实现。 1、 https://redis.io/topics/streams-intro 2、 https://www.runoob.com/redis/redis-stream.html

最近在看 redis 这方面的知识，发现在 redis5 中产生了一种新的数据类型 Stream ，它和 kafka 的设计有些类似，可以当作一个简单的消息队列来使用。 解释： xadd 命令 返回的是数据的id, xx-yy (xx指的是毫秒数,yy指的是在这个毫秒内的第几条消息) 指定指定Stream的大小比模糊指定Stream的大小会稍微多少消耗一些性能。 ~ 模糊指定流的大小，可以看到指定的是1，实际上已经到了3. 使用redis的事务操作，获取到同一毫秒产生的多条数据，时间戳一样，序列号不一样 -: 表示最小id的值 +: 表示最大id的值 (: 表示开区间 直接写 毫秒 不写后面的序列号即可。 start 和 end 的值写的一样即可获取单挑数据。 使用 count 进行限制 使用方式和 XRANGE 类似，略。 需求： 往Stream中加入3条消息，然后删除第2条消息 注意： 需要注意的是，我们从Stream中删除一个消息，这个消息并不是被真正的删除了，而是被 标记为删除 ，这个时候这个消息还是占据着内容空间的。如果所有Stream中所有的消息都被标记删除，这个时候才会回收内存空间。但是这个Stream并不会被删除。 查看Stream中元素的长度 注意： 如果 xlen 后方的 key 不存在则返回0，否则返回元素的个数。 上方的意思是，保留 stream-key 这个Stream中最后的2个消息。 minid 是删除比这个id小的数据，本地测试的时候 没有测试出来 ，略。 XREAD 只是读取消息，读取完之后并不会删除消息。 使用 XREAD 读取消息，是完全独立与消费者组的，多个客户端可以同时读取消息。 count 限制单次读取最后的消息，因为当前读取可能没有这么多。 即读取队列尾的下一个消息，在非阻塞模式下始终是 nil 注意： 1、创建Stream的名称是 stream-key 2、创建2个消息，aa和bb $ 表示从最后一个元素消费，不包括Stream中的最后一个元素，即消费最新的消息。 1636362619125-0 某个消息的具体的ID,这个 g3 消费者组中的消息都是 大于> 这个id的消息。 也可以通过 xautoclaim 来实现。

这是最主要的部分：This is how Pub/Sub works performance wise in Redis.You have two things.1) Subscribers to channels (SUBSCRIBE)2) Subscribers to *patterns* (PSUBSCRIBE)3) Publishers (PUBLISH)You can consider the work of subscribing/unsubscribing as a constanttime operation, O(1) for both subscribing and unsubscribing(actually PSUBSCRIBE does more work than this if you are subscribedalready to many patterns with the *same* client).All the complexity on the end is on the PUBLISH command, that performsan amount of work that is proportional to:a) The number of clients receiving the message.b) The number of clients subscribed to a pattern, even if they"ll notmatch the message.This means that if you have N clients subscribed to 100000 differentchannels, everything will be super fast.If you have instead 10000 clients subscribed to the same channel,PUBLISH commands against this channel will be slow, and take maybe afew milliseconds (not sure about the actual time taken). Since we haveto send the same message to everybody.Also, if you have clients subscribed to 10000 *patterns* publish willbe slower than usually, but the work to do for every existing patternis smaller compared to the work that there is to do for every client*receiving* the message.About memory, it is similar or smaller than the one used by a key, soyou should not have problems to subscribe to millions of channels evenin a small server.Salvatore

redis有单独的setTimeout方法吗？是你使用的客户端设定的这个方法吧，对于redis中存储的key有过期超时时间设置，但是这个过期时间跟你的这个setTimeout明显不是一回事。仔细看看你的客户端的这个方法操作的是啥

最近往服务的消息推送上加了一个分布式的锁，用来防止短时间内相同消息重复处理的情况，思路是用redis的setnx 设置一个key(key值根据业务制定，需要唯一)，然后设置key的超时时间为5分钟，用于防止系统异常时没有主动释放锁的防御，在线上灰度环境试运行后，发现两个问题，一个是程序没有主动释放锁，另一个是redis没有删除超时过期的key，导致key值一直存在，后续的操作一直被排斥。 经调查发现，第一个问题，程序没有主动释放key值，是因为key值有一部分引用了业务消息的状态，即格式为：systemA-cluster-lock-业务id-status-action，其中status在处理前后发生了变化导致没能删除原来的key，做法是通过copy多一份key值保留； 第二个问题：redis没有删除超时过期的key，通过ttl key命令查看，return 0，通过查看官方文档 https://redis.io/commands/ttl ，redis的ttl返回的是剩余过期时间，当key不存在时返回-2，即没有返回0的情况。继续折腾，终于在 https://blog.csdn.net/alexhendar/article/details/50857176 这边博客中找到了答案，原来和redis的配置有关，当redis为slave且read_only关闭时，redis不会删除过期的key值，此时ttl key返回0，通过查看redis配置，果然如此，于是修改redis配置，第二个问题得解。

该类实现了UserDetails接口 内含登录成功或失败后的处理方法 用一个简单的类来接受前端出来的登录信息 实现UserDetailsService接口，重写loadUserByUsername方法，按自己的实际需求来编写验证规则 该类为token校验器，并封装了用户权限，保存至security上下文中 首先SysUserController中有三个测试接口，第一个接口认证后即可访问，第二个接口需要登录的用户拥有ROLE_ADMIN角色，第三个接口需要用户拥有ROLE_USER角色。 返回了token信息 请求头中带上token，因为security配置类中关闭了session，后续请求必须带上token才能访问。 访问成功。 该接口需要ROLE_ADMIN，我们已登录的用户只拥有ROLE_USER，所以该接口不能访问。 结果符合预期 该接口需要ROLE_USER，已登录用户可以访问 结果符合预期 项目源码地址： https://github.com/lan-de/SpringSecurity-01

JWT是JSON WEB TOKEN的缩写，它是基于 RFC 7519 标准定义的一种可以安全传输的的JSON对象，由于使用了数字签名，所以是可信任和安全的。JWT的组成JWT token的格式：header.payload.signatureheader中用于存放签名的生成算法{"alg": "HS512"}Copy to clipboardErrorCopiedpayload中用于存放用户名、token的生成时间和过期时间{"sub":"admin","created":1489079981393,"exp":1489684781}Copy to clipboardErrorCopiedsignature为以header和payload生成的签名，一旦header和payload被篡改，验证将失败//secret为加密算法的密钥 String signature = HMACSHA512(base64UrlEncode(header) + "." +base64UrlEncode(payload),secret)

1.问题描述jwt与token+redis，哪种方案更好用？问题结论刚好最近有项目使用了jwt，而且是定制化的jwt的认证机制，就个人的理解而言，各自有其优缺点，并且针对不同的场景需要进行约束性开发，如用户剔除、同一用户每2h只生成一次jwt等。2.Token机制简述2.1Token的用途用户在登录APP时，APP端会发送加密的用户名和密码到服务器，服务器验证用户名和密码，如果验证成功，就会生成相应位数的字符产作为token存储到服务器中，并且将该token返回给APP端。以后APP再次请求时，凡是需要验证的地方都要带上该token，然后服务器端验证token，成功返回所需要的结果，失败返回错误信息，让用户重新登录。其中，服务器上会给token设置一个有效期，每次APP请求的时候都验证token和有效期。在存储的时候把token进行对称加密存储，用到的时候再解密。文章最开始提到的签名sign：将请求URL、时间戳、token三者合并，通过算法进行加密处理。2.2token+redis机制用户验证通过后，服务端通过如uuid相关的方法，生成token，存储用户信息。当请求服务时，客户端将token带上来，进行查询验证，如token存在并在有限期内，请求有效，否则请求非法。token+redis机制是中心化的，每次验证token有效性时，都需要访问redis，其核心优点实服务端可以主动让token失效，缺点是每次都要进行redis查询。占用redis存储空间。2.3jwt机制这是一种无状态身份验证机制，因为用户状态永远不会保存在服务器内存中。服务器受保护的路由将在授权头中检查有效的JWT，如果存在，则允许用户访问受保护的资源。由于JWT是独立的，所有必要的信息都在那里，减少了多次查询数据库的需求。Javajwt普遍选用java-jwt工具包依赖，gradle依赖：compile"com.auth0:java-jwt:3.2.0"用户发起登录请求，验证通过后，服务端创建一个加密后的JWT信息，作为Token返回。在后续请求中JWT信息作为请求头，发给服务端。服务端拿到JWT之后进行解密，正确解密表示此次请求合法，验证通过；解密失败说明Token无效或者已过期。jwt的有点主要有：a.其是去中心化的，便于分布式系统使用；2.基本信息可以直接放在token中。user_id，session_id；3.功能权限信息可以直接放在token中。用bit位表示用户所具有的功能权限。其缺点有：服务端无法主动让token失效，另一个是无法很好的控制payload的数据量。3.小结jwt和token+redis两种方案，没有最优，只有结合不同的业务场景，需求最适合的方案。就比如token2h过期，同一用户每1.5h只生成一次token，当两次token并存时，同时有效。大家可以考虑在这两种方案的前提下，分别如何实现？

下载有道字典，ta可以解决很多英语问题

这个是运行用Visual C++写的软件的支持库，不同版本不兼容（包括不同子版本直接也不兼容），所以才会有这么多。看了一眼我电脑上也有11个，每个都不大，除非强迫症，不然就留着吧。

Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。 Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。 hash类型可以理解为map集合，{key1:value1,key2:value2} 实例 Hash 的应用场景： 将一个用户作为一个 hash ，然后其属性和值就作为内部的 k-v 集合进行存储 例如 user:1 代表第 1 个用户，然后这个用户具有 name，age，job 这些字段，因为 redis 效率很高，因此适合将属性值经常变动的对象作为 hash 存储 个人理解和便于学习，进行了简单分类！ 分为以下几类： 下表列出了 redis hash 基本的相关命令： 更多命令请参考： https://redis.io/commands

C:WINDOWSSoftwareDistributionDownload里的文件可以删除。工具/材料：以win10为例。1、首先在桌面上，点击“此电脑”图标。2、然后在该界面中，地址栏输入“C:WINDOWSSoftwareDistributionDownload”。3、之后在该界面中，显示只有一个“SharedFileCache”分享地址缓存文件夹。4、接着在该界面中，双击打开“SharedFileCache”文件夹，显示里面没有东西。5、然后在该界面中，选中“SharedFileCache”文件夹，右键点击“删除”选项。6、最后在该界面中，显示文件删除成功。