前端技术
HTML
CSS
Javascript
前端框架和UI库
VUE
ReactJS
AngularJS
JQuery
NodeJS
JSON
Element-UI
Bootstrap
Material UI
服务端和客户端
Java
Python
PHP
Golang
Scala
Kotlin
Groovy
Ruby
Lua
.net
c#
c++
后端WEB和工程框架
SpringBoot
SpringCloud
Struts2
MyBatis
Hibernate
Tornado
Beego
Go-Spring
Go Gin
Go Iris
Dubbo
HessianRPC
Maven
Gradle
数据库
MySQL
Oracle
Mongo
中间件与web容器
Redis
MemCache
Etcd
Cassandra
Kafka
RabbitMQ
RocketMQ
ActiveMQ
Nacos
Consul
Tomcat
Nginx
Netty
大数据技术
Hive
Impala
ClickHouse
DorisDB
Greenplum
PostgreSQL
HBase
Kylin
Hadoop
Apache Pig
ZooKeeper
SeaTunnel
Sqoop
Datax
Flink
Spark
Mahout
数据搜索与日志
ElasticSearch
Apache Lucene
Apache Solr
Kibana
Logstash
数据可视化与OLAP
Apache Atlas
Superset
Saiku
Tesseract
系统与容器
Linux
Shell
Docker
Kubernetes
[基于Redis的限流实现]的搜索结果
这里是文章列表。热门标签的颜色随机变换,标签颜色没有特殊含义。
点击某个标签可搜索标签相关的文章。
点击某个标签可搜索标签相关的文章。
转载文章
... 和 lpop 可以实现消息队列(队尾进队头出),但是消费者需要不停地调用 lpop 查看 List 中是否有等待处理的消息(比如写一个 while 循环)。 为了减少通信的消耗,可以 sleep()一段时间再消费,但是会有两个问题: 1、如果生产者生产消息的速度远大于消费者消费消息的速度,List 会占用大量的内存。 2、消息的实时性降低。 list 还提供了一个阻塞的命令:blpop,没有任何元素可以弹出的时候,连接会被阻塞。 基于 list 实现的消息队列,不支持一对多的消息分发。 1.2 发布订阅模式 除了通过 list 实现消息队列之外,Redis 还提供了一组命令实现发布/订阅模式。 这种方式,发送者和接收者没有直接关联(实现了解耦),接收者也不需要持续尝试获取消息。 1.2.1 订阅频道 首先,我们有很多的频道(channel),我们也可以把这个频道理解成 queue。订阅者可以订阅一个或者多个频道。消息的发布者(生产者)可以给指定的频道发布消息。只要有消息到达了频道,所有订阅了这个频道的订阅者都会收到这条消息。 需要注意的注意是,发出去的消息不会被持久化,因为它已经从队列里面移除了,所以消费者只能收到它开始订阅这个频道之后发布的消息。 下面我们来看一下发布订阅命令的使用方法。 订阅者订阅频道:可以一次订阅多个,比如这个客户端订阅了 3 个频道。 subscribe channel-1 channel-2 channel-3 发布者可以向指定频道发布消息(并不支持一次向多个频道发送消息): publish channel-1 2673 取消订阅(不能在订阅状态下使用): unsubscribe channel-1 1.2.2 按规则(Pattern)订阅频道 支持 ?和 占位符。? 代表一个字符, 代表 0 个或者多个字符。 消费端 1,关注运动信息: psubscribe sport 消费端 2,关注所有新闻: psubscribe news 消费端 3,关注天气新闻: psubscribe news-weather 生产者,发布 3 条信息 publish news-sport yaoming publish news-music jaychou publish news-weather rain 2、Redis 事务 2.1 为什么要用事务 我们知道 Redis 的单个命令是原子性的(比如 get set mget mset),如果涉及到多个命令的时候,需要把多个命令作为一个不可分割的处理序列,就需要用到事务。 例如我们之前说的用 setnx 实现分布式锁,我们先 set,然后设置对 key 设置 expire, 防止 del 发生异常的时候锁不会被释放,业务处理完了以后再 del,这三个动作我们就希望它们作为一组命令执行。 Redis 的事务有两个特点: 1、按进入队列的顺序执行。 2、不会受到其他客户端的请求的影响。 Redis 的事务涉及到四个命令:multi(开启事务),exec(执行事务),discard (取消事务),watch(监视) 2.2 事务的用法 案例场景:tom 和 mic 各有 1000 元,tom 需要向 mic 转账 100 元。tom 的账户余额减少 100 元,mic 的账户余额增加 100 元。 通过 multi 的命令开启事务。事务不能嵌套,多个 multi 命令效果一样。 multi 执行后,客户端可以继续向服务器发送任意多条命令,这些命令不会立即被执行,而是被放到一个队列中,当 exec 命令被调用时,所有队列中的命令才会被执行。 通过 exec 的命令执行事务。如果没有执行 exec,所有的命令都不会被执行。如果中途不想执行事务了,怎么办? 可以调用 discard 可以清空事务队列,放弃执行。 2.3 watch命令 在 Redis 中还提供了一个 watch 命令。 它可以为 Redis 事务提供 CAS 乐观锁行为(Check and Set / Compare and Swap),也就是多个线程更新变量的时候,会跟原值做比较,只有它没有被其他线程修改的情况下,才更新成新的值。 我们可以用 watch 监视一个或者多个 key,如果开启事务之后,至少有一个被监视 key 键在 exec 执行之前被修改了,那么整个事务都会被取消(key 提前过期除外)。可以用 unwatch 取消。 2.4 事务可能遇到的问题 我们把事务执行遇到的问题分成两种,一种是在执行 exec 之前发生错误,一种是在执行 exec 之后发生错误。 2.4.1 在执行 exec 之前发生错误 比如:入队的命令存在语法错误,包括参数数量,参数名等等(编译器错误)。 在这种情况下事务会被拒绝执行,也就是队列中所有的命令都不会得到执行。 2.4.2 在执行 exec 之后发生错误 比如,类型错误,比如对 String 使用了 Hash 的命令,这是一种运行时错误。 最后我们发现 set k1 1 的命令是成功的,也就是在这种发生了运行时异常的情况下, 只有错误的命令没有被执行,但是其他命令没有受到影响。 这个显然不符合我们对原子性的定义,也就是我们没办法用 Redis 的这种事务机制来实现原子性,保证数据的一致。 3、Lua脚本 Lua/ˈluə/是一种轻量级脚本语言,它是用 C 语言编写的,跟数据的存储过程有点类似。 使用 Lua 脚本来执行 Redis 命令的好处: 1、一次发送多个命令,减少网络开销。 2、Redis 会将整个脚本作为一个整体执行,不会被其他请求打断,保持原子性。 3、对于复杂的组合命令,我们可以放在文件中,可以实现程序之间的命令集复用。 3.1 在Redis中调用Lua脚本 使用 eval /ɪ’væl/ 方法,语法格式: redis> eval lua-script key-num [key1 key2 key3 ....] [value1 value2 value3 ....] eval代表执行Lua语言的命令。 lua-script代表Lua语言脚本内容。 key-num表示参数中有多少个key,需要注意的是Redis中key是从1开始的,如果没有key的参数,那么写0。 [key1key2key3…]是key作为参数传递给Lua语言,也可以不填,但是需要和key-num的个数对应起来。 [value1 value2 value3 …]这些参数传递给 Lua 语言,它们是可填可不填的。 示例,返回一个字符串,0 个参数: redis> eval "return 'Hello World'" 0 3.2 在Lua脚本中调用Redis命令 使用 redis.call(command, key [param1, param2…])进行操作。语法格式: redis> eval "redis.call('set',KEYS[1],ARGV[1])" 1 lua-key lua-value command是命令,包括set、get、del等。 key是被操作的键。 param1,param2…代表给key的参数。 注意跟 Java 不一样,定义只有形参,调用只有实参。 Lua 是在调用时用 key 表示形参,argv 表示参数值(实参)。 3.2.1 设置键值对 在 Redis 中调用 Lua 脚本执行 Redis 命令 redis> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 gupao 2673 redis> get gupao 以上命令等价于 set gupao 2673。 在 redis-cli 中直接写 Lua 脚本不够方便,也不能实现编辑和复用,通常我们会把脚本放在文件里面,然后执行这个文件。 3.2.2 在 Redis 中调用 Lua 脚本文件中的命令,操作 Redis 创建 Lua 脚本文件: cd /usr/local/soft/redis5.0.5/src vim gupao.lua Lua 脚本内容,先设置,再取值: cd /usr/local/soft/redis5.0.5/src redis-cli --eval gupao.lua 0 得到返回值: root@localhost src] redis-cli --eval gupao.lua 0 "lua666" 3.2.3 案例:对 IP 进行限流 需求:在 X 秒内只能访问 Y 次。 设计思路:用 key 记录 IP,用 value 记录访问次数。 拿到 IP 以后,对 IP+1。如果是第一次访问,对 key 设置过期时间(参数 1)。否则判断次数,超过限定的次数(参数 2),返回 0。如果没有超过次数则返回 1。超过时间, key 过期之后,可以再次访问。 KEY[1]是 IP, ARGV[1]是过期时间 X,ARGV[2]是限制访问的次数 Y。 -- ip_limit.lua-- IP 限流,对某个 IP 频率进行限制 ,6 秒钟访问 10 次 local num=redis.call('incr',KEYS[1])if tonumber(num)==1 thenredis.call('expire',KEYS[1],ARGV[1])return 1elseif tonumber(num)>tonumber(ARGV[2]) thenreturn 0 elsereturn 1 end 6 秒钟内限制访问 10 次,调用测试(连续调用 10 次): ./redis-cli --eval "ip_limit.lua" app:ip:limit:192.168.8.111 , 6 10 app:ip:limit:192.168.8.111 是 key 值 ,后面是参数值,中间要加上一个空格和一个逗号,再加上一个空格 。 即:./redis-cli –eval [lua 脚本] [key…]空格,空格[args…] 多个参数之间用一个空格分割 。 代码:LuaTest.java 3.2.4 缓存 Lua 脚本 为什么要缓存 在脚本比较长的情况下,如果每次调用脚本都需要把整个脚本传给 Redis 服务端, 会产生比较大的网络开销。为了解决这个问题,Redis 提供了 EVALSHA 命令,允许开发者通过脚本内容的 SHA1 摘要来执行脚本。 如何缓存 Redis 在执行 script load 命令时会计算脚本的 SHA1 摘要并记录在脚本缓存中,执行 EVALSHA 命令时 Redis 会根据提供的摘要从脚本缓存中查找对应的脚本内容,如果找到了则执行脚本,否则会返回错误:“NOSCRIPT No matching script. Please use EVAL.” 127.0.0.1:6379> script load "return 'Hello World'" "470877a599ac74fbfda41caa908de682c5fc7d4b"127.0.0.1:6379> evalsha "470877a599ac74fbfda41caa908de682c5fc7d4b" 0 "Hello World" 3.2.5 自乘案例 Redis 有 incrby 这样的自增命令,但是没有自乘,比如乘以 3,乘以 5。我们可以写一个自乘的运算,让它乘以后面的参数: local curVal = redis.call("get", KEYS[1]) if curVal == false thencurVal = 0 elsecurVal = tonumber(curVal)endcurVal = curVal tonumber(ARGV[1]) redis.call("set", KEYS[1], curVal) return curVal 把这个脚本变成单行,语句之间使用分号隔开 local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal script load ‘命令’ 127.0.0.1:6379> script load 'local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal' "be4f93d8a5379e5e5b768a74e77c8a4eb0434441" 调用: 127.0.0.1:6379> set num 2OK127.0.0.1:6379> evalsha be4f93d8a5379e5e5b768a74e77c8a4eb0434441 1 num 6 (integer) 12 3.2.6 脚本超时 Redis 的指令执行本身是单线程的,这个线程还要执行客户端的 Lua 脚本,如果 Lua 脚本执行超时或者陷入了死循环,是不是没有办法为客户端提供服务了呢? eval 'while(true) do end' 0 为了防止某个脚本执行时间过长导致 Redis 无法提供服务,Redis 提供了 lua-time-limit 参数限制脚本的最长运行时间,默认为 5 秒钟。 lua-time-limit 5000(redis.conf 配置文件中) 当脚本运行时间超过这一限制后,Redis 将开始接受其他命令但不会执行(以确保脚本的原子性,因为此时脚本并没有被终止),而是会返回“BUSY”错误。 Redis 提供了一个 script kill 的命令来中止脚本的执行。新开一个客户端: script kill 如果当前执行的 Lua 脚本对 Redis 的数据进行了修改(SET、DEL 等),那么通过 script kill 命令是不能终止脚本运行的。 127.0.0.1:6379> eval "redis.call('set','gupao','666') while true do end" 0 因为要保证脚本运行的原子性,如果脚本执行了一部分终止,那就违背了脚本原子性的要求。最终要保证脚本要么都执行,要么都不执行。 127.0.0.1:6379> script kill(error) UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the scripttermination or kill the server in a hard way using the SHUTDOWN NOSAVE command. 遇到这种情况,只能通过 shutdown nosave 命令来强行终止 redis。 shutdown nosave 和 shutdown 的区别在于 shutdown nosave 不会进行持久化操作,意味着发生在上一次快照后的数据库修改都会丢失。 4、Redis 为什么这么快? 4.1 Redis到底有多快? 根据官方的数据,Redis 的 QPS 可以达到 10 万左右(每秒请求数)。 4.2 Redis为什么这么快? 总结:1)纯内存结构、2)单线程、3)多路复用 4.2.1 内存 KV 结构的内存数据库,时间复杂度 O(1)。 第二个,要实现这么高的并发性能,是不是要创建非常多的线程? 恰恰相反,Redis 是单线程的。 4.2.2 单线程 单线程有什么好处呢? 1、没有创建线程、销毁线程带来的消耗 2、避免了上线文切换导致的 CPU 消耗 3、避免了线程之间带来的竞争问题,例如加锁释放锁死锁等等 4.2.3 异步非阻塞 异步非阻塞 I/O,多路复用处理并发连接。 4.3 Redis为什么是单线程的? 不是白白浪费了 CPU 的资源吗? 因为单线程已经够用了,CPU 不是 redis 的瓶颈。Redis 的瓶颈最有可能是机器内存或者网络带宽。既然单线程容易实现,而且 CPU 不会成为瓶颈,那就顺理成章地采用单线程的方案了。 4.4 单线程为什么这么快? 因为 Redis 是基于内存的操作,我们先从内存开始说起。 4.4.1 虚拟存储器(虚拟内存 Vitual Memory) 名词解释:主存:内存;辅存:磁盘(硬盘) 计算机主存(内存)可看作一个由 M 个连续的字节大小的单元组成的数组,每个字节有一个唯一的地址,这个地址叫做物理地址(PA)。早期的计算机中,如果 CPU 需要内存,使用物理寻址,直接访问主存储器。 这种方式有几个弊端: 1、在多用户多任务操作系统中,所有的进程共享主存,如果每个进程都独占一块物理地址空间,主存很快就会被用完。我们希望在不同的时刻,不同的进程可以共用同一块物理地址空间。 2、如果所有进程都是直接访问物理内存,那么一个进程就可以修改其他进程的内存数据,导致物理地址空间被破坏,程序运行就会出现异常。 为了解决这些问题,我们就想了一个办法,在 CPU 和主存之间增加一个中间层。CPU 不再使用物理地址访问,而是访问一个虚拟地址,由这个中间层把地址转换成物理地址,最终获得数据。这个中间层就叫做虚拟存储器(Virtual Memory)。 具体的操作如下所示: 在每一个进程开始创建的时候,都会分配一段虚拟地址,然后通过虚拟地址和物理地址的映射来获取真实数据,这样进程就不会直接接触到物理地址,甚至不知道自己调用的哪块物理地址的数据。 目前,大多数操作系统都使用了虚拟内存,如 Windows 系统的虚拟内存、Linux 系统的交换空间等等。Windows 的虚拟内存(pagefile.sys)是磁盘空间的一部分。 在 32 位的系统上,虚拟地址空间大小是 2^32bit=4G。在 64 位系统上,最大虚拟地址空间大小是多少? 是不是 2^64bit=10241014TB=1024PB=16EB?实际上没有用到 64 位,因为用不到这么大的空间,而且会造成很大的系统开销。Linux 一般用低 48 位来表示虚拟地址空间,也就是 2^48bit=256T。 cat /proc/cpuinfo address sizes : 40 bits physical, 48 bits virtual 实际的物理内存可能远远小于虚拟内存的大小。 总结:引入虚拟内存,可以提供更大的地址空间,并且地址空间是连续的,使得程序编写、链接更加简单。并且可以对物理内存进行隔离,不同的进程操作互不影响。还可以通过把同一块物理内存映射到不同的虚拟地址空间实现内存共享。 4.4.2 用户空间和内核空间 为了避免用户进程直接操作内核,保证内核安全,操作系统将虚拟内存划分为两部分,一部分是内核空间(Kernel-space)/ˈkɜːnl /,一部分是用户空间(User-space)。 内核是操作系统的核心,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件设备的权限。 内核空间中存放的是内核代码和数据,而进程的用户空间中存放的是用户程序的代码和数据。不管是内核空间还是用户空间,它们都处于虚拟空间中,都是对物理地址的映射。 在 Linux 系统中, 内核进程和用户进程所占的虚拟内存比例是 1:3。 当进程运行在内核空间时就处于内核态,而进程运行在用户空间时则处于用户态。 进程在内核空间以执行任意命令,调用系统的一切资源;在用户空间只能执行简单的运算,不能直接调用系统资源,必须通过系统接口(又称 system call),才能向内核发出指令。 top 命令: us 代表 CPU 消耗在 User space 的时间百分比; sy 代表 CPU 消耗在 Kernel space 的时间百分比。 4.4.3 进程切换(上下文切换) 多任务操作系统是怎么实现运行远大于 CPU 数量的任务个数的? 当然,这些任务实际上并不是真的在同时运行,而是因为系统通过时间片分片算法,在很短的时间内,将 CPU 轮流分配给它们,造成多任务同时运行的错觉。 为了控制进程的执行,内核必须有能力挂起正在 CPU 上运行的进程,并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。 什么叫上下文? 在每个任务运行前,CPU 都需要知道任务从哪里加载、又从哪里开始运行,也就是说,需要系统事先帮它设置好 CPU 寄存器和程序计数器(ProgramCounter),这个叫做 CPU 的上下文。 而这些保存下来的上下文,会存储在系统内核中,并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响,让任务看起来还是连续运行。 在切换上下文的时候,需要完成一系列的工作,这是一个很消耗资源的操作。 4.4.4 进程的阻塞 正在运行的进程由于提出系统服务请求(如 I/O 操作),但因为某种原因未得到操作系统的立即响应,该进程只能把自己变成阻塞状态,等待相应的事件出现后才被唤醒。 进程在阻塞状态不占用 CPU 资源。 4.4.5 文件描述符 FD Linux 系统将所有设备都当作文件来处理,而 Linux 用文件描述符来标识每个文件对象。 文件描述符(File Descriptor)是内核为了高效管理已被打开的文件所创建的索引,用于指向被打开的文件,所有执行 I/O 操作的系统调用都通过文件描述符;文件描述符是一个简单的非负整数,用以表明每个被进程打开的文件。 Linux 系统里面有三个标准文件描述符。 0:标准输入(键盘); 1:标准输出(显示器); 2:标准错误输出(显示器)。 4.4.6 传统 I/O 数据拷贝 以读操作为例: 当应用程序执行 read 系统调用读取文件描述符(FD)的时候,如果这块数据已经存在于用户进程的页内存中,就直接从内存中读取数据。如果数据不存在,则先将数据从磁盘加载数据到内核缓冲区中,再从内核缓冲区拷贝到用户进程的页内存中。(两次拷贝,两次 user 和 kernel 的上下文切换)。 I/O 的阻塞到底阻塞在哪里? 4.4.7 Blocking I/O 当使用 read 或 write 对某个文件描述符进行过读写时,如果当前 FD 不可读,系统就不会对其他的操作做出响应。从设备复制数据到内核缓冲区是阻塞的,从内核缓冲区拷贝到用户空间,也是阻塞的,直到 copy complete,内核返回结果,用户进程才解除 block 的状态。 为了解决阻塞的问题,我们有几个思路。 1、在服务端创建多个线程或者使用线程池,但是在高并发的情况下需要的线程会很多,系统无法承受,而且创建和释放线程都需要消耗资源。 2、由请求方定期轮询,在数据准备完毕后再从内核缓存缓冲区复制数据到用户空间 (非阻塞式 I/O),这种方式会存在一定的延迟。 能不能用一个线程处理多个客户端请求? 4.4.8 I/O 多路复用(I/O Multiplexing) I/O 指的是网络 I/O。 多路指的是多个 TCP 连接(Socket 或 Channel)。 复用指的是复用一个或多个线程。它的基本原理就是不再由应用程序自己监视连接,而是由内核替应用程序监视文件描述符。 客户端在操作的时候,会产生具有不同事件类型的 socket。在服务端,I/O 多路复用程序(I/O Multiplexing Module)会把消息放入队列中,然后通过文件事件分派器(File event Dispatcher),转发到不同的事件处理器中。 多路复用有很多的实现,以 select 为例,当用户进程调用了多路复用器,进程会被阻塞。内核会监视多路复用器负责的所有 socket,当任何一个 socket 的数据准备好了,多路复用器就会返回。这时候用户进程再调用 read 操作,把数据从内核缓冲区拷贝到用户空间。 所以,I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符,而这些文件描述符(套接字描述符)其中的任意一个进入读就绪(readable)状态,select() 函数就可以返回。 Redis 的多路复用, 提供了 select, epoll, evport, kqueue 几种选择,在编译的时 候来选择一种。 evport 是 Solaris 系统内核提供支持的; epoll 是 LINUX 系统内核提供支持的; kqueue 是 Mac 系统提供支持的; select 是 POSIX 提供的,一般的操作系统都有支撑(保底方案); 源码 ae_epoll.c、ae_select.c、ae_kqueue.c、ae_evport.c 5、内存回收 Reids 所有的数据都是存储在内存中的,在某些情况下需要对占用的内存空间进行回 收。内存回收主要分为两类,一类是 key 过期,一类是内存使用达到上限(max_memory) 触发内存淘汰。 5.1 过期策略 要实现 key 过期,我们有几种思路。 5.1.1 定时过期(主动淘汰) 每个设置过期时间的 key 都需要创建一个定时器,到过期时间就会立即清除。该策略可以立即清除过期的数据,对内存很友好;但是会占用大量的 CPU 资源去处理过期的 数据,从而影响缓存的响应时间和吞吐量。 5.1.2 惰性过期(被动淘汰) 只有当访问一个 key 时,才会判断该 key 是否已过期,过期则清除。该策略可以最大化地节省 CPU 资源,却对内存非常不友好。极端情况可能出现大量的过期 key 没有再次被访问,从而不会被清除,占用大量内存。 例如 String,在 getCommand 里面会调用 expireIfNeeded server.c expireIfNeeded(redisDb db, robj key) 第二种情况,每次写入 key 时,发现内存不够,调用 activeExpireCycle 释放一部分内存。 expire.c activeExpireCycle(int type) 5.1.3 定期过期 源码:server.h typedef struct redisDb { dict dict; / 所有的键值对 /dict expires; / 设置了过期时间的键值对 /dict blocking_keys; dict ready_keys; dict watched_keys; int id;long long avg_ttl;list defrag_later; } redisDb; 每隔一定的时间,会扫描一定数量的数据库的 expires 字典中一定数量的 key,并清除其中已过期的 key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时,可以在不同情况下使得 CPU 和内存资源达到最优的平衡效果。 Redis 中同时使用了惰性过期和定期过期两种过期策略。 5.2 淘汰策略 Redis 的内存淘汰策略,是指当内存使用达到最大内存极限时,需要使用淘汰算法来决定清理掉哪些数据,以保证新数据的存入。 5.2.1 最大内存设置 redis.conf 参数配置: maxmemory <bytes> 如果不设置 maxmemory 或者设置为 0,64 位系统不限制内存,32 位系统最多使用 3GB 内存。 动态修改: redis> config set maxmemory 2GB 到达最大内存以后怎么办? 5.2.2 淘汰策略 https://redis.io/topics/lru-cache redis.conf maxmemory-policy noeviction 先从算法来看: LRU,Least Recently Used:最近最少使用。判断最近被使用的时间,目前最远的数据优先被淘汰。 LFU,Least Frequently Used,最不常用,4.0 版本新增。 random,随机删除。 如果没有符合前提条件的 key 被淘汰,那么 volatile-lru、volatile-random、 volatile-ttl 相当于 noeviction(不做内存回收)。 动态修改淘汰策略: redis> config set maxmemory-policy volatile-lru 建议使用 volatile-lru,在保证正常服务的情况下,优先删除最近最少使用的 key。 5.2.3 LRU 淘汰原理 问题:如果基于传统 LRU 算法实现 Redis LRU 会有什么问题? 需要额外的数据结构存储,消耗内存。 Redis LRU 对传统的 LRU 算法进行了改良,通过随机采样来调整算法的精度。如果淘汰策略是 LRU,则根据配置的采样值 maxmemory_samples(默认是 5 个), 随机从数据库中选择 m 个 key, 淘汰其中热度最低的 key 对应的缓存数据。所以采样参数m配置的数值越大, 就越能精确的查找到待淘汰的缓存数据,但是也消耗更多的CPU计算,执行效率降低。 问题:如何找出热度最低的数据? Redis 中所有对象结构都有一个 lru 字段, 且使用了 unsigned 的低 24 位,这个字段用来记录对象的热度。对象被创建时会记录 lru 值。在被访问的时候也会更新 lru 的值。 但是不是获取系统当前的时间戳,而是设置为全局变量 server.lruclock 的值。 源码:server.h typedef struct redisObject {unsigned type:4;unsigned encoding:4;unsigned lru:LRU_BITS;int refcount;void ptr; } robj; server.lruclock 的值怎么来的? Redis 中有个定时处理的函数 serverCron,默认每 100 毫秒调用函数 updateCachedTime 更新一次全局变量的 server.lruclock 的值,它记录的是当前 unix 时间戳。 源码:server.c void updateCachedTime(void) { time_t unixtime = time(NULL); atomicSet(server.unixtime,unixtime); server.mstime = mstime();struct tm tm; localtime_r(&server.unixtime,&tm);server.daylight_active = tm.tm_isdst; } 问题:为什么不获取精确的时间而是放在全局变量中?不会有延迟的问题吗? 这样函数 lookupKey 中更新数据的 lru 热度值时,就不用每次调用系统函数 time,可以提高执行效率。 OK,当对象里面已经有了 LRU 字段的值,就可以评估对象的热度了。 函数 estimateObjectIdleTime 评估指定对象的 lru 热度,思想就是对象的 lru 值和全局的 server.lruclock 的差值越大(越久没有得到更新),该对象热度越低。 源码 evict.c / Given an object returns the min number of milliseconds the object was never requested, using an approximated LRU algorithm. /unsigned long long estimateObjectIdleTime(robj o) {unsigned long long lruclock = LRU_CLOCK(); if (lruclock >= o->lru) {return (lruclock - o->lru) LRU_CLOCK_RESOLUTION; } else {return (lruclock + (LRU_CLOCK_MAX - o->lru)) LRU_CLOCK_RESOLUTION;} } server.lruclock 只有 24 位,按秒为单位来表示才能存储 194 天。当超过 24bit 能表 示的最大时间的时候,它会从头开始计算。 server.h define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) / Max value of obj->lru / 在这种情况下,可能会出现对象的 lru 大于 server.lruclock 的情况,如果这种情况 出现那么就两个相加而不是相减来求最久的 key。 为什么不用常规的哈希表+双向链表的方式实现?需要额外的数据结构,消耗资源。而 Redis LRU 算法在 sample 为 10 的情况下,已经能接近传统 LRU 算法了。 问题:除了消耗资源之外,传统 LRU 还有什么问题? 如图,假设 A 在 10 秒内被访问了 5 次,而 B 在 10 秒内被访问了 3 次。因为 B 最后一次被访问的时间比 A 要晚,在同等的情况下,A 反而先被回收。 问题:要实现基于访问频率的淘汰机制,怎么做? 5.2.4 LFU server.h typedef struct redisObject {unsigned type:4;unsigned encoding:4;unsigned lru:LRU_BITS;int refcount;void ptr; } robj; 当这 24 bits 用作 LFU 时,其被分为两部分: 高 16 位用来记录访问时间(单位为分钟,ldt,last decrement time) 低 8 位用来记录访问频率,简称 counter(logc,logistic counter) counter 是用基于概率的对数计数器实现的,8 位可以表示百万次的访问频率。 对象被读写的时候,lfu 的值会被更新。 db.c——lookupKey void updateLFU(robj val) {unsigned long counter = LFUDecrAndReturn(val); counter = LFULogIncr(counter);val->lru = (LFUGetTimeInMinutes()<<8) | counter;} 增长的速率由,lfu-log-factor 越大,counter 增长的越慢 redis.conf 配置文件。 lfu-log-factor 10 如果计数器只会递增不会递减,也不能体现对象的热度。没有被访问的时候,计数器怎么递减呢? 减少的值由衰减因子 lfu-decay-time(分钟)来控制,如果值是 1 的话,N 分钟没有访问就要减少 N。 redis.conf 配置文件 lfu-decay-time 1 6、持久化机制 https://redis.io/topics/persistence Redis 速度快,很大一部分原因是因为它所有的数据都存储在内存中。如果断电或者宕机,都会导致内存中的数据丢失。为了实现重启后数据不丢失,Redis 提供了两种持久化的方案,一种是 RDB 快照(Redis DataBase),一种是 AOF(Append Only File)。 6.1 RDB RDB 是 Redis 默认的持久化方案。当满足一定条件的时候,会把当前内存中的数据写入磁盘,生成一个快照文件 dump.rdb。Redis 重启会通过加载 dump.rdb 文件恢复数据。 什么时候写入 rdb 文件? 6.1.1 RDB 触发 1、自动触发 a)配置规则触发。 redis.conf, SNAPSHOTTING,其中定义了触发把数据保存到磁盘的触发频率。 如果不需要 RDB 方案,注释 save 或者配置成空字符串""。 save 900 1 900 秒内至少有一个 key 被修改(包括添加) save 300 10 400 秒内至少有 10 个 key 被修改save 60 10000 60 秒内至少有 10000 个 key 被修改 注意上面的配置是不冲突的,只要满足任意一个都会触发。 RDB 文件位置和目录: 文件路径,dir ./ 文件名称dbfilename dump.rdb 是否是LZF压缩rdb文件 rdbcompression yes 开启数据校验 rdbchecksum yes 问题:为什么停止 Redis 服务的时候没有 save,重启数据还在? RDB 还有两种触发方式: b)shutdown 触发,保证服务器正常关闭。 c)flushall,RDB 文件是空的,没什么意义(删掉 dump.rdb 演示一下)。 2、手动触发 如果我们需要重启服务或者迁移数据,这个时候就需要手动触 RDB 快照保存。Redis 提供了两条命令: a)save save 在生成快照的时候会阻塞当前 Redis 服务器, Redis 不能处理其他命令。如果内存中的数据比较多,会造成 Redis 长时间的阻塞。生产环境不建议使用这个命令。 为了解决这个问题,Redis 提供了第二种方式。 执行 bgsave 时,Redis 会在后台异步进行快照操作,快照同时还可以响应客户端请求。 具体操作是 Redis 进程执行 fork 操作创建子进程(copy-on-write),RDB 持久化过程由子进程负责,完成后自动结束。它不会记录 fork 之后后续的命令。阻塞只发生在 fork 阶段,一般时间很短。 用 lastsave 命令可以查看最近一次成功生成快照的时间。 6.1.2 RDB 数据的恢复(演示) 1、shutdown 持久化添加键值 添加键值 redis> set k1 1 redis> set k2 2 redis> set k3 3 redis> set k4 4 redis> set k5 5 停服务器,触发 save redis> shutdown 备份 dump.rdb 文件 cp dump.rdb dump.rdb.bak 启动服务器 /usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf 啥都没有: redis> keys 3、通过备份文件恢复数据停服务器 redis> shutdown 重命名备份文件 mv dump.rdb.bak dump.rdb 启动服务器 /usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf 查看数据 redis> keys 6.1.3 RDB 文件的优势和劣势 一、优势 1.RDB 是一个非常紧凑(compact)的文件,它保存了 redis 在某个时间点上的数据集。这种文件非常适合用于进行备份和灾难恢复。 2.生成 RDB 文件的时候,redis 主进程会 fork()一个子进程来处理所有保存工作,主进程不需要进行任何磁盘 IO 操作。 3.RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。 二、劣势 1、RDB 方式数据没办法做到实时持久化/秒级持久化。因为 bgsave 每次运行都要执行 fork 操作创建子进程,频繁执行成本过高。 2、在一定间隔时间做一次备份,所以如果 redis 意外 down 掉的话,就会丢失最后一次快照之后的所有修改(数据有丢失)。 如果数据相对来说比较重要,希望将损失降到最小,则可以使用 AOF 方式进行持久化。 6.2 AOF Append Only File AOF:Redis 默认不开启。AOF 采用日志的形式来记录每个写操作,并追加到文件中。开启后,执行更改 Redis 数据的命令时,就会把命令写入到 AOF 文件中。 Redis 重启时会根据日志文件的内容把写指令从前到后执行一次以完成数据的恢复工作。 6.2.1 AOF 配置 配置文件 redis.conf 开关appendonly no 文件名appendfilename "appendonly.aof" AOF 文件的内容(vim 查看): 问题:数据都是实时持久化到磁盘吗? 由于操作系统的缓存机制,AOF 数据并没有真正地写入硬盘,而是进入了系统的硬盘缓存。什么时候把缓冲区的内容写入到 AOF 文件? 问题:文件越来越大,怎么办? 由于 AOF 持久化是 Redis 不断将写命令记录到 AOF 文件中,随着 Redis 不断的进行,AOF 的文件会越来越大,文件越大,占用服务器内存越大以及 AOF 恢复要求时间越长。 例如 set xxx 666,执行 1000 次,结果都是 xxx=666。 为了解决这个问题,Redis 新增了重写机制,当 AOF 文件的大小超过所设定的阈值时,Redis 就会启动 AOF 文件的内容压缩,只保留可以恢复数据的最小指令集。 可以使用命令 bgrewriteaof 来重写。 AOF 文件重写并不是对原文件进行重新整理,而是直接读取服务器现有的键值对,然后用一条命令去代替之前记录这个键值对的多条命令,生成一个新的文件后去替换原来的 AOF 文件。 重写触发机制 auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb 问题:重写过程中,AOF 文件被更改了怎么办? 另外有两个与 AOF 相关的参数: 6.2.2 AOF 数据恢复 重启 Redis 之后就会进行 AOF 文件的恢复。 6.2.3 AOF 优势与劣势 优点: 1、AOF 持久化的方法提供了多种的同步频率,即使使用默认的同步频率每秒同步一次,Redis 最多也就丢失 1 秒的数据而已。 缺点: 1、对于具有相同数据的的 Redis,AOF 文件通常会比 RDB 文件体积更大(RDB 存的是数据快照)。 2、虽然 AOF 提供了多种同步的频率,默认情况下,每秒同步一次的频率也具有较高的性能。在高并发的情况下,RDB 比 AOF 具好更好的性能保证。 6.3 两种方案比较 那么对于 AOF 和 RDB 两种持久化方式,我们应该如何选择呢? 如果可以忍受一小段时间内数据的丢失,毫无疑问使用 RDB 是最好的,定时生成 RDB 快照(snapshot)非常便于进行数据库备份, 并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快。 否则就使用 AOF 重写。但是一般情况下建议不要单独使用某一种持久化机制,而是应该两种一起用,在这种情况下,当 redis 重启的时候会优先载入 AOF 文件来恢复原始的数据,因为在通常情况下 AOF 文件保存的数据集要比 RDB 文件保存的数据集要完整。 本篇文章为转载内容。原文链接:https://blog.csdn.net/zhoutaochun/article/details/120075092。 该文由互联网用户投稿提供,文中观点代表作者本人意见,并不代表本站的立场。 作为信息平台,本站仅提供文章转载服务,并不拥有其所有权,也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况,请及时联系我们,我们将第一时间进行核实并删除相应内容。
2024-03-18 12:25:04
541
转载
MemCache
...e之外,还可以设置如Redis等二级缓存,或者在应用本地进行临时缓存,以防止MemCache集群整体失效时完全依赖数据库。 (3)限流降级与熔断机制 当检测到缓存雪崩可能发生时(如缓存大量未命中),可以启动限流策略,限制对数据库的访问频次,并返回降级内容(如默认值、错误页面等)。下面是一个简单的限流实现示例: python from ratelimiter import RateLimiter limiter = RateLimiter(max_calls=100, period=60) 每分钟最多100次数据库查询 def get_data_from_db(key): if not limiter.hit(): raise Exception("Too many requests, fallback to default value.") 实际执行数据库查询操作... data = db.query_data(key) return data 同时,结合熔断器模式,如Hystrix,可以在短时间内大量失败后自动进入短路状态,不再尝试访问数据库。 (4)缓存预热与更新策略 在MemCache重启或大规模缓存失效后,可预先加载部分热点数据,即缓存预热。另外,我们可以采用异步更新或者懒加载的方式来耍个小聪明,处理缓存更新的问题。这样一来,就不会因为网络偶尔闹情绪、卡个壳什么的,引发可怕的雪崩效应了。 总结起来,面对MemCache中的缓存雪崩风险,我们需要理解其根源,运用多维度的防御策略,并结合实际业务场景灵活调整,才能确保我们的系统具备更高的可用性和韧性。在这个过程里,我们不断摸爬滚打,亲身实践、深刻反思,然后再一步步优化提升。这正是技术引人入胜之处,同样也是每一位开发者在成长道路上必经的重要挑战和修炼课题。
2023-12-27 23:36:59
88
蝶舞花间
Go Gin
...ratelimit 实现 API 访问控制:一次深入探索 一、引言 在构建现代 Web 应用时,API 的安全性与性能管理是至关重要的环节。哎呀,兄弟,你懂的,设置API访问频率的限制这事儿啊,就像是给自家的宝藏门口放了个看门狗,既能防止那些乱糟糟的家伙随便闯进来搞破坏,又能保护咱们的宝贝资源不被那些坏心眼的人给掏空了。这招儿,可真是既实用又有效呢!哎呀,你知道吗?Go 语言这玩意儿,那可是超级厉害的!它就像个武林高手,出手快如闪电,又稳如泰山。用 Go 来做网站啥的,不仅效率高得飞起,代码还简洁明了,看着都舒服。而且,你放心,用 Go 做的网站安全性能杠杠的,能防得住不少小偷小摸呢!所以啊,现在好多大厂做高性能、安全的网络服务,都喜欢用 Go 语言来搞,因为它真的太牛了!gin-contrib/ratelimit 是一个用于 Go 语言中 Gin 框架的库,专门用于实现 API 访问速率限制。本文将深入探讨如何利用 gin-contrib/ratelimit 来增强 API 安全性和性能。 二、基础概念与原理 速率限制(也称为限流)是一种常见的流量控制手段,它允许系统在单位时间内处理的请求数量不超过某个阈值。哎呀,你瞧这招儿挺机灵的!它能帮咱们解决一个大难题——就是那些疯了似的并发请求,就像一群蚂蚁围攻面包,瞬间就把服务器给淹没了。这样不仅能让我们的服务器喘口气,不至于被这些请求给累趴下,还能给那些没权没份的家伙们上上锁,别让他们乱用咱们的API,搞得咱们这边乱七八糟的。这招儿,既保护了服务器,又守住了规矩,真是一举两得啊! gin-contrib/ratelimit 提供了一种简单且灵活的方式来配置和应用速率限制规则。它支持多种存储后端,包括内存、Redis 和数据库等,以适应不同的应用场景需求。 三、安装与初始化 首先,确保你的 Go 环境已经配置好,并且安装了 gin-contrib/ratelimit 库。可以通过以下命令进行安装: bash go get github.com/gin-contrib/ratelimit 接下来,在你的 Gin 应用中引入并初始化 ratelimit 包: go import ( "github.com/gin-contrib/ratelimit" "github.com/gin-gonic/gin" ) func main() { r := gin.Default() // 配置限流器 limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, // 允许每分钟最多5次请求 Duration: time.Minute, }) // 将限流器应用于路由 r.Use(limiter) // 定义路由 r.GET("/api", func(c gin.Context) { c.JSON(200, gin.H{"message": "Hello, World!"}) }) r.Run(":8080") } 四、高级功能与自定义 除了基本的速率限制配置外,gin-contrib/ratelimit 还提供了丰富的高级功能,允许开发者根据具体需求进行定制化设置。 - 基于 IP 地址的限制: go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, Duration: time.Minute, PermitsBy: ratelimit.PermitByIP, }) - 基于 HTTP 请求头的限制: go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, Duration: time.Minute, PermitsBy: ratelimit.PermitByHeader("X-User-ID"), }) - 基于用户会话的限制: go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 5, Duration: time.Minute, PermitsBy: ratelimit.PermitBySessionID, }) 这些高级功能允许你更精细地控制哪些请求会被限制,从而提供更精确的访问控制策略。 五、实践案例 基于 IP 地址的限流 假设我们需要限制某个特定 IP 地址的访问频率: go limiter := ratelimit.New(ratelimit.Config{ AllowedRequests: 10, // 每小时最多10次请求 Duration: time.Hour, PermitsBy: ratelimit.PermitByIP, }) // 在路由上应用限流器 r.Use(limiter) 六、性能考量与优化 在实际部署时,考虑到速率限制的性能影响,合理配置限流参数至关重要。哎呀,你得注意了,设定安全防护的时候,这事儿得拿捏好度才行。要是设得太严,就像在门口挂了个大锁,那些坏人进不来,可合法的访客也被挡在外头了,这就有点儿不地道了。反过来,如果设置的门槛太松,那可就相当于给小偷开了个后门,让各种风险有机可乘。所以啊,找那个平衡点,既不让真正的朋友感到不便,又能守住自家的安全,才是王道!因此,建议结合业务场景和流量预测进行参数调整。 同时,选择合适的存储后端也是性能优化的关键。哎呀,你知道的,在处理那些超级多人同时在线的情况时,咱们用 Redis 来当存储小能手,那效果简直不要太好!它就像个神奇的魔法箱,能飞快地帮我们处理各种数据,让系统运行得又顺溜又高效,简直是高并发环境里的大救星呢! 七、结论 通过集成 gin-contrib/ratelimit,我们不仅能够有效地管理 API 访问频率,还能够在保障系统稳定运行的同时,为用户提供更好的服务体验。嘿,兄弟!业务这玩意儿,那可是风云变幻,快如闪电。就像你开车,路况不一,得随时调整方向,对吧?API安全性和可用性这事儿,就跟你的车一样重要。所以,咱们得像老司机一样,灵活应对各种情况,时不时地调整和优化限流策略。这样,不管是高峰还是低谷,都能稳稳地掌控全局,让你的业务顺畅无阻,安全又高效。别忘了,这可是保护咱们业务不受攻击,保证用户体验的关键!希望本文能够帮助你更好地理解和应用 gin-contrib/ratelimit,在构建强大、安全的 API 时提供有力的支持。
2024-08-24 16:02:03
109
山涧溪流
Beego
...3协议的逐步普及,其基于QUIC的低延迟传输特性为Web请求处理带来了新的优化可能。例如,Cloudflare等云服务提供商已经开始支持HTTP/3,并公开分享了在实际业务场景中采用HTTP/3后带来的性能提升数据,这对于Beego这类Web框架在HTTP请求处理层面的优化提供了前瞻性的指导。 此外,对于缓存策略的研究也在不断深化,Redis Labs近期推出的RediSearch模块,增强了Redis对复杂查询的支持,使得开发者能够在缓存层实现更高效的检索操作,从而在保证响应速度的同时减轻数据库压力,这也是Beego应用性能优化的一个重要方向。 总之,在持续探索性能优化的过程中,密切关注行业前沿技术和最佳实践,结合具体应用场景灵活运用,才能确保我们的应用程序始终保持高效稳定的运行状态。
2024-01-18 18:30:40
537
清风徐来-t
Redis
Redis的数据同步机制 1. Redis数据同步机制概述 大家好,今天我们要聊聊Redis中的一个非常重要的部分——数据同步机制。作为一个超级喜欢研究数据库技术的人,我经常琢磨在分布式系统里怎么才能让数据又一致又靠谱。Redis可真是个处理大数据和高并发的高手,特别是在数据同步这方面,它的重要性不言而喻。它不仅关乎数据的安全性,还直接影响着系统的可用性和性能。 那么,什么是数据同步机制呢?简单来说,就是当主节点上的数据发生变化时,如何将这些变化同步到其他节点,从而保证所有节点的数据一致性。这听上去好像只是简单地复制一下,但实际上背后藏着不少复杂的机制和技术细节呢。 2. 主从复制 在Redis中,最基础也是最常用的一种数据同步机制就是主从复制(Master-Slave Replication)。你可以这么理解这种机制:就像是有个老大(Master)专门处理写入数据的活儿,而其他的小弟(Slave)们则主要负责读取和备份这些数据。 2.1 基本原理 假设我们有一个主节点和两个从节点,当主节点接收到一条写入命令时,它会将这条命令记录在一个称为“复制积压缓冲区”(Replication Buffer)的特殊内存区域中。然后,主节点会异步地将这个命令发送给所有的从节点。从节点收到命令后,会将其应用到自己的数据库中,以确保数据的一致性。 2.2 代码示例 让我们来看一个简单的代码示例,首先启动一个主节点: bash redis-server --port 6379 接着,启动两个从节点,分别监听不同的端口: bash redis-server --slaveof 127.0.0.1 6379 --port 6380 redis-server --slaveof 127.0.0.1 6379 --port 6381 现在,如果你向主节点写入一条数据,比如: bash redis-cli -p 6379 set key value 这条数据就会被同步到两个从节点上。你可以通过以下命令验证: bash redis-cli -p 6380 get key redis-cli -p 6381 get key 你会发现,两个从节点都正确地收到了这条数据。 3. 哨兵模式 哨兵模式(Sentinel Mode)是Redis提供的另一种高可用解决方案。它的主要功能就是在主节点挂掉后,自动选出一个新老大,并告诉所有的小弟们赶紧换队长。这使得Redis能够更好地应对单点故障问题。 3.1 工作原理 哨兵模式由一组哨兵实例组成,它们负责监控Redis实例的状态。当哨兵发现主节点挂了,就会用Raft算法选出一个新老大,并告诉所有的小弟们赶紧更新配置信息。这个过程是自动完成的,无需人工干预。 3.2 代码示例 要启用哨兵模式,需要先配置哨兵实例。假设你已经安装了Redis,并且主节点运行在localhost:6379上。接下来,你需要创建一个哨兵配置文件sentinels.conf,内容如下: conf sentinel monitor mymaster 127.0.0.1 6379 2 sentinel down-after-milliseconds mymaster 5000 sentinel failover-timeout mymaster 60000 sentinel parallel-syncs mymaster 1 然后启动哨兵实例: bash redis-sentinel sentinels.conf 现在,当你故意关闭主节点时,哨兵会自动选举出一个新的主节点,并通知从节点进行切换。 4. 集群模式 最后,我们来看看Redis集群模式(Cluster Mode),这是一种更加复杂但也更强大的数据同步机制。集群模式允许Redis实例分布在多个节点上,每个节点都可以同时处理读写请求。 4.1 集群架构 在集群模式下,Redis实例被划分为多个槽(slots),每个槽可以归属于不同的节点。当你用客户端连到某个节点时,它会通过键名算出应该去哪个槽,然后就把请求直接发到对的节点上。这样做的好处是,即使某个节点宕机,也不会影响整个系统的可用性。 4.2 实现步骤 为了建立一个Redis集群,你需要准备至少六个Redis实例,每个实例监听不同的端口。然后,使用redis-trib.rb工具来创建集群: bash redis-trib.rb create --replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 创建完成后,你可以通过任何节点来访问集群。例如: bash redis-cli -c -h 127.0.0.1 -p 7000 5. 总结 通过以上介绍,我们可以看到Redis提供了多种数据同步机制,每种机制都有其独特的应用场景。不管是基本的主从复制,还是复杂的集群模式,Redis都能搞定数据同步,让人放心。当然啦,每种方法都有它的长处和短处,到底选哪个还得看你自己的具体情况和所处的环境。希望今天的分享能对你有所帮助,也欢迎大家在评论区讨论更多关于Redis的话题!
2025-03-05 15:47:59
27
草原牧歌
Redis
一、Redis简介与重要性 Redis,作为一款高效的数据结构存储系统,以其在内存中处理数据的能力和丰富的数据类型支持,在分布式缓存、键值对存储以及实时分析等领域扮演着核心角色。你知道吗,一个状态棒棒哒、表现贼6的Redis服务器,那可是能够轻松应对海量用户的并发请求!这其中有一个特别重要的“小开关”——最大连接数(maxclients),它就像是Redis在高并发环境下的“定海神针”,直接关系到Redis的表现力和稳定性。 二、为什么要关注Redis的最大连接数 Redis最大连接数限制了同一时间内可以有多少客户端与其建立连接并发送请求。当这个数值被突破时,不好意思,新的连接就得乖乖排队等候了,只有等当前哪个连接完成了任务,腾出位置来,新的连接才有机会连进来。因此,合理设置最大连接数至关重要: - 避免资源耗尽:过多的连接可能导致Redis消耗完所有的文件描述符(通常是内核限制),从而无法接受新连接。 - 提高响应速度:过低的连接数可能导致客户端间的竞争,特别是对于频繁读取缓存的情况,过多的等待会导致整体性能下降。 - 维护系统稳定性:过高或者过低的连接数都可能引发各种问题,如资源争抢、网络拥堵、服务器负载不均等。 三、Redis最大连接数的设置步骤 1. 查看Redis默认最大连接数 打开Redis配置文件redis.conf,找到如下行: Default value for maxclients, can be overridden by the command line option maxclients 10000 这就是Redis服务器的默认最大连接数,通常在生产环境中会根据需求进行调整。 2. 修改Redis最大连接数配置 为了演示,我们把最大连接数设为250: 在redis.conf 文件中添加或替换原有maxclients 设置 maxclients 250 确保修改后的配置文件正确无误,并遵循以下原则来确定合适的最大连接数: - 根据预期并发用户量计算所需连接数,一般来说,每个活跃用户至少维持一个持久连接,加上一定的冗余。 - 考虑Redis任务类型:如果主要用于写入操作,如持久化任务,适当增加连接数可加快数据同步;若主要是读取,那么连接数可根据平均并发读取量设置。 - 参考服务器硬件资源:CPU、内存、磁盘I/O等资源水平,以防止因连接数过多导致Redis服务响应变慢或崩溃。 3. 保存并重启Redis服务 完成配置后,记得保存更改并重启Redis服务以使新配置生效: bash Linux 示例 sudo service redis-server restart macOS 或 Docker 使用以下命令 sudo redis-cli config save docker-compose restart redis 4. 检查并监控Redis最大连接数 重启Redis服务后,通过info clients命令检查最大连接数是否已更新: redis-cli info clients 输出应包含connected_clients这一字段,显示当前活跃连接数量,以及maxClients显示允许的最大连接数。 5. 监控系统资源及文件描述符限制 在Linux环境下,可以通过ulimit -n查看当前可用的文件描述符限制,若仍需进一步增大连接数,请通过ulimit -n 设置并重加载限制,然后再重启Redis服务使其受益于新设置。 四、结论与注意事项 设置Redis最大连接数并非一劳永逸,随着业务发展和环境变化,定期评估并调整这一参数是必要的。同时,想要确保Redis既能满足业务需求又能始终保持流畅稳定运行,就得把系统资源监控、Redis的各项性能指标和调优策略一起用上,像拼图一样把它们完美结合起来。在这个过程中,我们巧妙地把实际操作中积累的经验和书本上的理论知识灵活融合起来,让Redis摇身一变,成了推动我们业务迅猛发展的超级好帮手。
2024-02-01 11:01:33
301
彩虹之上_t
Redis
...。 二、设计思路 要实现这个功能,我们可以利用Redis这种键值对存储的数据库来存储用户的阅读状态。我们可以把每篇文章看作一个键,而用户的阅读状态则可以看作一个值。当有用户点开一篇文章瞧瞧的时候,我们就能通过查这个小标签的记录,轻松判断出这位用户是不是已经拜读过这篇文章啦。 三、具体实现 接下来我们将详细介绍如何使用Redis实现这个功能。首先,我们需要创建一个新的键值对存储表,并且为每个文章创建一个键。比如,假设有这么一个叫做“news”的文章列表,我们完全可以给列表里的每一篇文章都创建一个独特的标签,就像这样子:“news:article1”,“news:article2”等等,就像是给每篇文章起了个专属的小名儿一样。 然后,我们需要为用户创建一个键,用于存储他们的阅读状态。例如,我们可以为每个用户创建一个名为"user:uid:read_status"的键,其中"uid"是用户的唯一标识符。 当用户访问一篇文章时,我们可以通过查询"news:articleX"这个键的值来获取文章的阅读状态。如果这个键的值为空,则表示用户还未阅读过这篇文章。反之,如果这个键的值不为空,则表示用户已经阅读过这篇文章。 接下来,我们可以通过修改"news:articleX"这个键的值来更新文章的阅读状态。比如,当咱发现有用户已经阅读过某篇文章了,咱们就可以把这篇文章对应的键值标记为"true",就像在小本本上做个记号一样。换种说法,假如我们发现用户还没读过某篇文章呢,那咱们就可以干脆把这篇文章对应的键的值清空掉,让它变成空空如也。 四、代码示例 下面是一个使用Python实现的简单示例: python import redis 创建Redis客户端对象 r = redis.Redis(host='localhost', port=6379, db=0) 获取文章的阅读状态 def get_article_read_status(article_id): key = f'news:{article_id}:read_status' return r.get(key) is not None 更新文章的阅读状态 def set_article_read_status(article_id, read_status): key = f'news:{article_id}:read_status' if read_status: r.set(key, 'true') else: r.delete(key) 五、总结 通过上述介绍,我们可以看到,使用Redis作为阅读状态数据库是一种非常可行的方法。它可以方便地存储和管理用户的阅读状态,而且因为Redis的特性,它的性能非常高,可以很好地应对高并发的情况。 当然,这只是一个基本的设计方案,实际的应用可能还需要考虑更多的因素,例如安全性、稳定性、可扩展性等等。不管咋说,Redis这款数据库工具真心值得我给你安利一波。它可是能实实在在地帮我们简化开发过程,这样一来,咱就能把更多的心思和精力花在琢磨业务逻辑上,让工作更加高效流畅。
2023-06-24 14:53:48
332
岁月静好_t
Redis
一、引言 Redis,这个强大的内存数据结构存储系统,以其高速、灵活和分布式特性赢得了广大开发者的心。你知道吗,当我们在Redis里找不到某个键的位置,想要给它安个新值时,Redis这家伙就像个贴心的魔术师,轻轻松松就给出了超高效又不失风度的办法。本文将带你深入了解这一过程,通过实例解析其背后的逻辑和应用场景。 二、Redis基础知识 首先,让我们回顾一下Redis的基本概念。Redis支持多种数据结构,如字符串(String)、哈希(Hash)、列表(List)、集合(Set)和有序集合(Sorted Set)。键(Key)是存储数据的唯一标识,而值(Value)则是存储的具体内容。当你试着给Redis一个压根不存在的键来设定值,嘿,这小家伙会根据不同数据结构的脾性,来个智能的操作。 三、键不存在的设置操作 1. 字符串类型(String) 在Redis中,如果尝试设置一个不存在的字符串键,它会直接创建这个键并设置相应的值。例如: python import redis r = redis.Redis(host='localhost', port=6379, db=0) r.set('my_key', 'Hello, Redis!') 如果my_key不存在,Redis会自动创建并设置值为Hello, Redis!。 2. 哈希类型(Hash) 对于哈希类型,我们可以指定一个键来存储一个关联数组。同样,如果键不存在,Redis会自动创建: python r.hset('hash_key', 'field1', 'value1') 如果hash_key不存在,Redis会创建一个新哈希并将field1与value1关联起来。 四、过期时间和自动删除 Redis允许我们为键设置过期时间,当超过设定的时间后,键将自动被删除。即使键不存在,我们也可以设置过期时间: python r.expire('non_existent_key', 60) 设置键过期时间为60秒 r.set('non_existent_key', 'Will be deleted soon') 设置值 这里,non_existent_key将在60秒后被自动删除,即使之前不存在。 五、总结与讨论 在实际开发中,键不存在但尝试设置值的情况非常常见,尤其是当我们需要预设数据结构或者进行数据初始化的时候。Redis的这种灵活性使得它在缓存、消息队列等领域大放异彩。你知道吗,掌握那种“找不到键也能应对自如”的技巧,就像打理生活琐事一样重要,能帮咱们高效地管理数据,省下那些不必要的麻烦和资源。 总的来说,Redis的强大不仅仅在于它的性能,更在于其设计的灵活性和易用性。懂透这些基本技巧后,就像给应用程序穿上了一双疾速又稳健的红鞋,Redis能让你的应用跑得飞快又稳如老马,效率和稳定性双双升级!下次你碰到那个棘手的“按键没影子还想填值”的情况,不妨来点新鲜玩意儿——Redis,保证让你一试就爱上它的魔力!
2024-04-08 11:13:38
218
岁月如歌
MemCache
...可以通过其他方式间接实现数据的持久化。例如,可以定期将Memcached中的数据备份到数据库或其他持久化存储中: python 假设有一个从Memcached获取并持久化数据到MySQL的过程 def backup_to_mysql(): all_items = mc.get_multi(mc.keys()) for key, value in all_items.items(): save_to_mysql(key, value) 自定义保存到MySQL的函数 (2)组合使用Redis等具备持久化的缓存系统 另一个可行的方案是结合使用Redis等既具有高速缓存特性和又能持久化数据的系统。Redis不仅可以提供类似Memcached的内存缓存服务,还支持RDB和AOF两种持久化机制,能在一定程度上解决数据丢失的问题。 python import redis r = redis.Redis(host='localhost', port=6379, db=0) r.set('key', 'value') 在Redis中设置键值对,即使服务器重启,数据也能通过持久化机制得以恢复 (3)架构层面优化 在大型分布式系统中,可以通过设计冗余和分布式存储策略来降低单点故障带来的影响。比如,我们可以像搭积木那样部署多个Memcached实例,然后用一致性哈希这类聪明的算法给它们分配工作量和切分数据块。这样不仅能确保整体负载均衡,还能保证每一份数据都有好几个备份,分别存放在不同的节点上,就像把鸡蛋放在不同的篮子里一样,安全又可靠。 4. 结语 人类视角的理解与思考 面对Memcached数据丢失的问题,开发者们不能止步于理解其原理,更应积极寻求有效的应对策略。这就像生活中我们对待易逝的事物,尽管明白“天下无不散之筵席”,但我们依然会拍照留念、撰写日记,以期留住美好瞬间。同样,在我们使用Memcached这玩意儿的时候,也得充分了解它的脾性,借助一些巧妙的技术手段和设计架构,让数据既能痛快地享受高速缓存带来的速度福利,又能机智地避开数据丢失的坑。只有这样,我们的系统才能在效率与可靠性之间取得最佳平衡,更好地服务于业务需求。
2023-05-22 18:41:39
83
月影清风
转载文章
...xit; 9. 安装Redis sudo apt-get install -y redis-server 修改配置文件 sudo vim /etc/redis/redis.conf 重启 sudo systemctl restart redis sudo systemctl enable redis-server 10. 安装Nginx sudo apt-get install -y nginx 修改配置文件 sudo vim /etc/nginx/nginx.conf 重启 sudo systemctl restart nginx sudo systemctl enable nginx 11. 安装VMWare Workstation 下载 https://www.vmware.com/go/getworkstation-linux 放到文件夹,进入,执行 sudo chmod +x VMware-Workstation-Full-17.0.0-20800274.x86_64.bundle sudo ./VMware-Workstation-Full-17.0.0-20800274.x86_64.bundle 安装gcc sudo apt-get install -y gcc 进入控制台,找到VMWare,开始安装,安装过程同Windows 如果如果遇到build environment error错误,执行下列命令后再重新在控制台打开图标 sudo apt-get install -y libcanberra 如果还不行,执行 sudo vmware-modconfig --console --install-all 看看还缺什么 12. 安装百度网盘 官网下载Linux版本的软件:百度网盘 客户端下载 deepin的软件包格式为deb。安装: sudo dpkg -i baidunetdisk_3.5.0_amd64.deb 最新版本 sudo dpkg -i baidunetdisk_4.17.7_amd64.deb 如果报错,执行 sudo apt-get -f install 13. 安装WPS 官网下载Linux版本的软件:WPS Office 2019 for Linux-支持多版本下载_WPS官方网站 deepin的软件包格式为deb。安装: sudo dpkg -i wps-office_11.1.0.10702_amd64.deb 最新版本 sudo dpkg -i wps-office_11.1.0.11691_amd64.deb 如果报错执行 sudo apt-get -f install wps有可能会报缺字体,缺的字体如下,双击安装 百度网盘 请输入提取码 提取码:lexo 14. 安装VS Code 官网下载Linux版本的软件:Visual Studio Code - Code Editing. Redefined deepin的软件包格式为deb。安装: sudo dpkg -i code_1.61.1-1634175470_amd64.deb 最新版本 sudo dpkg -i code_1.76.0-1677667493_amd64.deb 如果报错执行 sudo apt-get -f install 15. 安装微信、QQ、迅雷 微信 sudo apt-get install -y com.qq.weixin.deepin QQ sudo apt-get install -y com.qq.im.deepin 迅雷 sudo apt-get install -y com.xunlei.download 16. 安装视频播放器 sudo apt-get -y install smplayer sudo apt-get -y install vlc 17. 安装SSH工具electerm 下载electerm的deb版本 deepin的软件包格式为deb。安装: https://github.com/electerm/electerm/releases/download/v1.25.16/electerm-1.25.16-linux-amd64.deb sudo dpkg -i electerm-1.25.16-linux-amd64.deb 18.安装FTP/SFTP工具FileZilla sudo apt-get -y install filezilla 19. 安装edge浏览器 下载edge浏览器 deepin的软件包格式为deb。安装: 下载 Microsoft Edge sudo apt-get -y install fonts-liberation sudo apt-get -y install libu2f-udev sudo dpkg -i microsoft-edge-beta_95.0.1020.30-1_amd64.deb 最新版本 sudo dpkg -i microsoft-edge-stable_110.0.1587.63-1_amd64.deb 本篇文章为转载内容。原文链接:https://blog.csdn.net/weixin_42173947/article/details/119973703。 该文由互联网用户投稿提供,文中观点代表作者本人意见,并不代表本站的立场。 作为信息平台,本站仅提供文章转载服务,并不拥有其所有权,也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况,请及时联系我们,我们将第一时间进行核实并删除相应内容。
2023-11-15 19:14:44
54
转载
Redis
如何在Redis中实现分布式锁的隔离性? 1. 分布式锁是什么?为什么我们需要它? 兄弟们,先别急着看代码!咱们得搞清楚一个最基本的问题——什么是分布式锁?简单来说,分布式锁就是一种用来协调多个进程或者服务之间共享资源的技术手段。嘿,你有没有想过啊?就相当于你有个超大的储物间(数据库或者其他服务),里面塞满了各种好玩意儿(数据),想拿啥就能拿啥!嘿,想象一下,现在有一群小毛贼(服务实例)都盯上了你的那些值钱的小宝贝,可不能让他们随便进来顺手牵羊啊!所以呢,你就得准备一把“神奇的钥匙”(锁),谁要是想进去拿东西,就必须先拿到这把钥匙才行。没有钥匙?不好意思,请自觉退散吧! 为什么要用分布式锁呢?因为在线上系统里,多台机器可能会同时操作同一个资源,比如抢购商品这种场景。如果没有锁机制的话,就可能出现重复下单、库存超卖等问题。分布式锁嘛,简单说就是抢车位的游戏规则——在同一时间里,只能有一个家伙抢到那个“资源位”,别的家伙就只能乖乖排队等着轮到自己啦! 不过说起来容易做起来难啊,尤其是在分布式环境下,网络延迟、机器宕机等问题会带来各种意想不到的情况。嘿,今天咱们就来唠唠,在Redis这个超级工具箱里,怎么才能整出个靠谱的分布式锁! --- 2. Redis为什么适合用来做分布式锁? 嘿,说到Redis,相信很多小伙伴都对它不陌生吧?Redis是一个基于内存的高性能键值存储系统,速度贼快,而且支持多种数据结构,比如字符串、哈希表、列表等等。最重要的是,它提供了原子性的操作指令,比如SETNX(Set if Not Exists),这让我们能够轻松地实现分布式锁! 让我给你们讲个小故事:有一次我尝试用数据库来做分布式锁,结果发现性能特别差劲,查询锁状态的SQL语句每次都要扫描整个表,效率低得让人抓狂。换了Redis之后,简直像开了挂一样,整个系统都丝滑得不行!Redis这玩意儿不光跑得快,还自带一堆黑科技,像什么过期时间、消息订阅啥的,这些功能简直就是搞分布式锁的神器啊! 所以,如果你也在纠结选什么工具来做分布式锁,强烈推荐试试Redis!接下来我会结合实际案例给你们展示具体的操作步骤。 --- 3. 实现分布式锁的基本思路 首先,我们要明确分布式锁需要满足哪些条件: 1. 互斥性 同一时刻只能有一个客户端持有锁。 2. 可靠性 即使某个客户端崩溃了,锁也必须自动释放,避免死锁。 3. 公平性 排队等待的客户端应该按照请求顺序获取锁。 4. 可重入性(可选) 允许同一个客户端多次获取同一个锁。 现在我们就来一步步实现这些功能。 示例代码 1:最基本的分布式锁实现 python import redis import time def acquire_lock(redis_client, lock_key, timeout=10): 尝试加锁,设置过期时间为timeout秒 result = redis_client.set(lock_key, "locked", nx=True, ex=timeout) return bool(result) def release_lock(redis_client, lock_key): 使用Lua脚本来保证解锁的安全性 script = """ if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end """ redis_client.eval(script, keys=[lock_key], args=["locked"]) 这段代码展示了最基础的分布式锁实现方式。我们用set命令设置了两个参数:一个是NX,意思是“只在key不存在的时候才创建”,这样就能避免重复创建;另一个是EX,给这个锁加了个过期时间,相当于设了个倒计时,万一客户端挂了或者出问题了,锁也能自动释放,就不会一直卡在那里变成死锁啦。最后,解锁的时候我们用了Lua脚本,这样可以保证操作的原子性。 --- 4. 如何解决锁的隔离性问题? 诶,说到这里,问题来了——如果两个不同的业务逻辑都需要用到同一个锁怎么办?比如订单系统和积分系统都想操作同一个用户的数据,这时候就需要考虑锁的隔离性了。换句话说,我们需要确保不同业务逻辑之间的锁不会互相干扰。 示例代码 2:基于命名空间的隔离策略 python def acquire_namespace_lock(redis_client, namespace, lock_name, timeout=10): 构造带命名空间的锁名称 lock_key = f"{namespace}:{lock_name}" result = redis_client.set(lock_key, "locked", nx=True, ex=timeout) return bool(result) def release_namespace_lock(redis_client, namespace, lock_name): lock_key = f"{namespace}:{lock_name}" script = """ if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end """ redis_client.eval(script, keys=[lock_key], args=["locked"]) 在这个版本中,我们在锁的名字前面加上了命名空间前缀,比如orders:place_order和points:update_score。这样一来,不同业务逻辑就可以使用独立的锁,避免相互影响。 --- 5. 进阶 如何处理锁竞争与性能优化? 当然啦,现实中的分布式锁并不会总是那么顺利,有时候会出现大量请求同时争抢同一个锁的情况。这时我们可能需要引入队列机制或者批量处理的方式来降低系统的压力。 示例代码 3:使用Redis的List模拟队列 python def enqueue_request(redis_client, queue_key, request_data): redis_client.rpush(queue_key, request_data) def dequeue_request(redis_client, queue_key): return redis_client.lpop(queue_key) def process_queue(redis_client, lock_key, queue_key): while True: 先尝试获取锁 if not acquire_lock(redis_client, lock_key): time.sleep(0.1) 等待一段时间再重试 continue 获取队列中的第一个请求并处理 request = dequeue_request(redis_client, queue_key) if request: handle_request(request) 释放锁 release_lock(redis_client, lock_key) 这段代码展示了如何利用Redis的List结构来管理请求队列。想象一下,好多用户一起抢同一个东西,场面肯定乱哄哄的对吧?这时候,咱们就让他们老老实实排成一队,然后派一个专门的小哥挨个儿去处理他们的请求。这样一来,大家就不会互相“打架”了,事情也能更顺利地办妥。 --- 6. 总结与反思 兄弟们,通过今天的讨论,我相信大家都对如何在Redis中实现分布式锁有了更深刻的理解了吧?虽然Redis本身已经足够强大,但我们仍然需要根据实际需求对其进行适当的扩展和优化。比如刚才提到的命名空间隔离、队列机制等,这些都是非常实用的小技巧。 不过呢,我也希望大家能记住一点——技术永远不是一成不变的。业务越做越大,技术也日新月异的,咱们得不停地充电,学点新鲜玩意儿,试试新招数才行啊!就像今天的分布式锁一样,也许明天就会有更高效、更优雅的解决方案出现。所以,保持好奇心,勇于探索未知领域,这才是程序员最大的乐趣所在! 好了,今天就聊到这里啦,祝大家在编程的路上越走越远!如果有任何疑问或者想法,欢迎随时找我交流哦~
2025-04-22 16:00:29
58
寂静森林
转载文章
...式事务解决方案 1、基于数据库XA协议的两段提交 XA协议是数据库支持的一种协议,其核心是一个事务管理器用来统一管理两个分布式数据库,如图 事务管理器负责跟支付宝数据库和余额宝数据库打交道,一旦有一个数据库连接失败,另一个数据库的操作就不会进行,一个数据库操作失败就会导致另一个数据库回滚,只有他们全部成功两个数据库的事务才会提交。 基于XA协议的两段和三段提交是一种严格的安全确认机制,其安全性是非常高的,但是保证安全性的前提是牺牲了性能,这个就是分布式系统里面的CAP理论,做任何架构的前提需要有取舍。所以基于XA协议的分布式事务并发性不高,不适合高并发场景。 2、基于activemq的解决方案 如图: 1、支付宝扣款成功时往message表插入消息 2、message表有message_id(流水id,标识夸系统的一次转账操作),status(confirm,unconfirm) 3、timer扫描message表的unconfirm状态记录往activemq插入消息 4、余额宝收到消息消费消息时先查询message表如果有记录就不处理如果没记录就进行数据库增款操作 5、如果余额宝数据库操作成功往余额宝message表插入消息,表字段跟支付宝message一致 6、如果5操作成功,回调支付宝接口修改message表状态,把unconfirm状态转换成confirm状态 问题描述: 1、支付宝设计message表的目的 如果支付宝往activemq插入消息而余额宝消费消息异常,有可能是消费消息成功而事务操作异常,有可能是网络异常等等不确定因素。如果出现异常而activemq收到了确认消息的信号,这时候activemq中的消息是删除了的,消息丢失了。设置message表就是有一个消息存根,activemq中消息丢失了message表中的消息还在。解决了activemq消息丢失问题 2、余额宝设计message表的目的 当余额宝消费成功并且数据库操作成功时,回调支付宝的消息确认接口,如果回调接口时出现异常导致支付宝状态修改失败还是unconfirm状态,这时候还会被timer扫描到,又会往activemq插入消息,又会被余额宝消费一边,但是这条消息已经消费成功了的只是回调失败而已,所以就需要有一个这样的message表,当余额宝消费时先插入message表,如果message根据message_id能查询到记录就说明之前这条消息被消费过就不再消费只需要回调成功即可,如果查询不到消息就消费这条消息继续数据库操作,数据库操作成功就往message表插入消息。 这样就解决了消息重复消费问题,这也是消费端的幂等操作。 基于消息中间件的分布式事务是最理想的分布式事务解决方案,兼顾了安全性和并发性! 接下来贴代码: 支付宝代码: @Controller@RequestMapping("/order")public class OrderController {/ @Description TODO @param @return 参数 @return String 返回类型 @throws userID:转账的用户ID amount:转多少钱/@Autowired@Qualifier("activemq")OrderService orderService;@RequestMapping("/transfer")public @ResponseBody String transferAmount(String userId,String messageId, int amount) {try {orderService.updateAmount(amount,messageId, userId);}catch (Exception e) {e.printStackTrace();return "===============================transferAmount failed===================";}return "===============================transferAmount successfull===================";}@RequestMapping("/callback")public String callback(String param) {JSONObject parse = JSONObject.parseObject(param);String respCode = parse.getString("respCode");if(!"OK".equalsIgnoreCase(respCode)) {return null;}try {orderService.updateMessage(param);}catch (Exception e) {e.printStackTrace();return "fail";}return "ok";} } public interface OrderService {public void updateAmount(int amount, String userId,String messageId);public void updateMessage(String param);} @Service("activemq")@Transactional(rollbackFor = Exception.class)public class OrderServiceActivemqImpl implements OrderService {Logger logger = LoggerFactory.getLogger(getClass());@AutowiredJdbcTemplate jdbcTemplate;@AutowiredJmsTemplate jmsTemplate;@Overridepublic void updateAmount(final int amount, final String messageId, final String userId) {String sql = "update account set amount = amount - ?,update_time=now() where user_id = ?";int count = jdbcTemplate.update(sql, new Object[]{amount, userId});if (count == 1) {//插入到消息记录表sql = "insert into message(user_id,message_id,amount,status) values (?,?,?,?)";int row = jdbcTemplate.update(sql,new Object[]{userId,messageId,amount,"unconfirm"});if(row == 1) {//往activemq中插入消息jmsTemplate.send("zg.jack.queue", new MessageCreator() {@Overridepublic Message createMessage(Session session) throws JMSException {com.zhuguang.jack.bean.Message message = new com.zhuguang.jack.bean.Message();message.setAmount(Integer.valueOf(amount));message.setStatus("unconfirm");message.setUserId(userId);message.setMessageId(messageId);return session.createObjectMessage(message);} });} }}@Overridepublic void updateMessage(String param) {JSONObject parse = JSONObject.parseObject(param);String messageId = parse.getString("messageId");String sql = "update message set status = ? where message_id = ?";int count = jdbcTemplate.update(sql,new Object[]{"confirm",messageId});if(count == 1) {logger.info(messageId + " callback successfull");} }} activemq.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:amq="http://activemq.apache.org/schema/core"xmlns:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.1.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.1.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms-4.1.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd"><context:component-scan base-package="com.zhuguang.jack" /><mvc:annotation-driven /><amq:connectionFactory id="amqConnectionFactory"brokerURL="tcp://192.168.88.131:61616"userName="system"password="manager" /><!-- 配置JMS连接工长 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><constructor-arg ref="amqConnectionFactory" /><property name="sessionCacheSize" value="100" /></bean><!-- 定义消息队列(Queue) --><bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue"><!-- 设置消息队列的名字 --><constructor-arg><value>zg.jack.queue</value></constructor-arg></bean><!-- 配置JMS模板(Queue),Spring提供的JMS工具类,它发送、接收消息。 --><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="connectionFactory" /><property name="defaultDestination" ref="demoQueueDestination" /><property name="receiveTimeout" value="10000" /><!-- true是topic,false是queue,默认是false,此处显示写出false --><property name="pubSubDomain" value="false" /></bean></beans> spring-dispatcher.xml <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:task="http://www.springframework.org/schema/task" xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util-3.2.xsdhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.2.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"><!-- 引入同文件夹下的redis属性配置文件 --><!-- 解决springMVC响应数据乱码 text/plain就是响应的时候原样返回数据--><import resource="../activemq/activemq.xml"/><!--<context:property-placeholder ignore-unresolvable="true" location="classpath:config/core/core.properties,classpath:config/redis/redis-config.properties" />--><bean id="propertyConfigurerForProject1" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="order" value="1" /><property name="ignoreUnresolvablePlaceholders" value="true" /><property name="location"><value>classpath:config/core/core.properties</value></property></bean><mvc:annotation-driven><mvc:message-converters register-defaults="true"><bean class="org.springframework.http.converter.StringHttpMessageConverter"><property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" /></bean></mvc:message-converters></mvc:annotation-driven><!-- 避免IE执行AJAX时,返回JSON出现下载文件 --><bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value></list></property></bean><!-- 开启controller注解支持 --><!-- 注:如果base-package=com.avicit 则注解事务不起作用 TODO 读源码 --><context:component-scan base-package="com.zhuguang"></context:component-scan><mvc:view-controller path="/" view-name="redirect:/index" /><beanclass="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /><bean id="handlerAdapter"class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"></bean><beanclass="org.springframework.web.servlet.view.ContentNegotiatingViewResolver"><property name="mediaTypes"><map><entry key="json" value="application/json" /><entry key="xml" value="application/xml" /><entry key="html" value="text/html" /></map></property><property name="viewResolvers"><list><bean class="org.springframework.web.servlet.view.BeanNameViewResolver" /><bean class="org.springframework.web.servlet.view.UrlBasedViewResolver"><property name="viewClass" value="org.springframework.web.servlet.view.JstlView" /><property name="prefix" value="/" /><property name="suffix" value=".jsp" /></bean></list></property></bean><!-- 支持上传文件 --> <!-- 控制器异常处理 --><bean id="exceptionResolver"class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"><property name="exceptionMappings"><props><prop key="java.lang.Exception">error</prop></props></property></bean><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"><property name="driverClass"><value>${jdbc.driverClassName}</value></property><property name="jdbcUrl"><value>${jdbc.url}</value></property><property name="user"><value>${jdbc.username}</value></property><property name="password"><value>${jdbc.password}</value></property><property name="minPoolSize" value="10" /><property name="maxPoolSize" value="100" /><property name="maxIdleTime" value="1800" /><property name="acquireIncrement" value="3" /><property name="maxStatements" value="1000" /><property name="initialPoolSize" value="10" /><property name="idleConnectionTestPeriod" value="60" /><property name="acquireRetryAttempts" value="30" /><property name="breakAfterAcquireFailure" value="false" /><property name="testConnectionOnCheckout" value="false" /><property name="acquireRetryDelay"><value>100</value></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /><aop:aspectj-autoproxy expose-proxy="true"/></beans> logback.xml <?xml version="1.0" encoding="UTF-8"?><!--scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒当scan为true时,此属性生效。默认的时间间隔为1分钟。debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。--><configuration scan="false" scanPeriod="60 seconds" debug="false"><!-- 定义日志的根目录 --><!-- <property name="LOG_HOME" value="/app/log" /> --><!-- 定义日志文件名称 --><property name="appName" value="netty"></property><!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 --><appender name="stdout" class="ch.qos.logback.core.ConsoleAppender"><Encoding>UTF-8</Encoding><!--日志输出格式:%d表示日期时间,%thread表示线程名,%-5level:级别从左显示5个字符宽度%logger{50} 表示logger名字最长50个字符,否则按照句点分割。 %msg:日志消息,%n是换行符--><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern></encoder></appender><!-- 滚动记录文件,先将日志记录到指定文件,当符合某个条件时,将日志记录到其他文件 --> <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender"><Encoding>UTF-8</Encoding><!-- 指定日志文件的名称 --> <file>${appName}.log</file><!--当发生滚动时,决定 RollingFileAppender 的行为,涉及文件移动和重命名TimeBasedRollingPolicy: 最常用的滚动策略,它根据时间来制定滚动策略,既负责滚动也负责出发滚动。--><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><!--滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}:按天进行日志滚动 %i:当文件大小超过maxFileSize时,按照i进行文件滚动--><fileNamePattern>${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern><!-- 可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。假设设置每天滚动,且maxHistory是365,则只保存最近365天的文件,删除之前的旧文件。注意,删除旧文件是,那些为了归档而创建的目录也会被删除。--><MaxHistory>365</MaxHistory><!-- 当日志文件超过maxFileSize指定的大小是,根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的,必须配置timeBasedFileNamingAndTriggeringPolicy--><timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><maxFileSize>100MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy></rollingPolicy><!--日志输出格式:%d表示日期时间,%thread表示线程名,%-5level:级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符,否则按照句点分割。 %msg:日志消息,%n是换行符--> <encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern></encoder></appender><!-- logger主要用于存放日志对象,也可以定义日志类型、级别name:表示匹配的logger类型前缀,也就是包的前半部分level:要记录的日志级别,包括 TRACE < DEBUG < INFO < WARN < ERRORadditivity:作用在于children-logger是否使用 rootLogger配置的appender进行输出,false:表示只用当前logger的appender-ref,true:表示当前logger的appender-ref和rootLogger的appender-ref都有效--><!-- <logger name="edu.hyh" level="info" additivity="true"><appender-ref ref="appLogAppender" /></logger> --><!-- root与logger是父子关系,没有特别定义则默认为root,任何一个类只会和一个logger对应,要么是定义的logger,要么是root,判断的关键在于找到这个logger,然后判断这个logger的appender和level。 --><root level="debug"><appender-ref ref="stdout" /><appender-ref ref="appLogAppender" /></root></configuration> 2、余额宝代码 package com.zhuguang.jack.controller;import com.alibaba.fastjson.JSONObject;import com.zhuguang.jack.service.OrderService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controller@RequestMapping("/order")public class OrderController {/ @Description TODO @param @return 参数 @return String 返回类型 @throws 模拟银行转账 userID:转账的用户ID amount:转多少钱/@AutowiredOrderService orderService;@RequestMapping("/transfer")public @ResponseBody String transferAmount(String userId, String amount) {try {orderService.updateAmount(Integer.valueOf(amount), userId);}catch (Exception e) {e.printStackTrace();return "===============================transferAmount failed===================";}return "===============================transferAmount successfull===================";} } 消息监听器 package com.zhuguang.jack.listener;import com.alibaba.fastjson.JSONObject;import com.zhuguang.jack.service.OrderService;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.client.SimpleClientHttpRequestFactory;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.client.RestTemplate;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageListener;import javax.jms.ObjectMessage;@Service("queueMessageListener")public class QueueMessageListener implements MessageListener {private Logger logger = LoggerFactory.getLogger(getClass());@AutowiredOrderService orderService;@Transactional(rollbackFor = Exception.class)@Overridepublic void onMessage(Message message) {if (message instanceof ObjectMessage) {ObjectMessage objectMessage = (ObjectMessage) message;try {com.zhuguang.jack.bean.Message message1 = (com.zhuguang.jack.bean.Message) objectMessage.getObject();String userId = message1.getUserId();int count = orderService.queryMessageCountByUserId(userId);if (count == 0) {orderService.updateAmount(message1.getAmount(), message1.getUserId());orderService.insertMessage(message1.getUserId(), message1.getMessageId(), message1.getAmount(), "ok");} else {logger.info("异常转账");}RestTemplate restTemplate = createRestTemplate();JSONObject jo = new JSONObject();jo.put("messageId", message1.getMessageId());jo.put("respCode", "OK");String url = "http://jack.bank_a.com:8080/alipay/order/callback?param="+ jo.toJSONString();restTemplate.getForObject(url,null);} catch (JMSException e) {e.printStackTrace();throw new RuntimeException("异常");} }}public RestTemplate createRestTemplate() {SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();simpleClientHttpRequestFactory.setConnectTimeout(3000);simpleClientHttpRequestFactory.setReadTimeout(2000);return new RestTemplate(simpleClientHttpRequestFactory);} } package com.zhuguang.jack.service;public interface OrderService {public void updateAmount(int amount, String userId);public int queryMessageCountByUserId(String userId);public int insertMessage(String userId,String messageId,int amount,String status);} package com.zhuguang.jack.service;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.client.SimpleClientHttpRequestFactory;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.client.RestTemplate;@Service@Transactional(rollbackFor = Exception.class)public class OrderServiceImpl implements OrderService {private Logger logger = LoggerFactory.getLogger(getClass());@AutowiredJdbcTemplate jdbcTemplate;/ 更新数据库表,把账户余额减去amountd/@Overridepublic void updateAmount(int amount, String userId) {//1、农业银行转账3000,也就说农业银行jack账户要减3000String sql = "update account set amount = amount + ?,update_time=now() where user_id = ?";int count = jdbcTemplate.update(sql, new Object[] {amount, userId});if (count != 1) {throw new RuntimeException("订单创建失败,农业银行转账失败!");} }public RestTemplate createRestTemplate() {SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();simpleClientHttpRequestFactory.setConnectTimeout(3000);simpleClientHttpRequestFactory.setReadTimeout(2000);return new RestTemplate(simpleClientHttpRequestFactory);}@Overridepublic int queryMessageCountByUserId(String messageId) {String sql = "select count() from message where message_id = ?";int count = jdbcTemplate.queryForInt(sql, new Object[]{messageId});return count;}@Overridepublic int insertMessage(String userId, String message_id,int amount, String status) {String sql = "insert into message(user_id,message_id,amount,status) values(?,?,?)";int count = jdbcTemplate.update(sql, new Object[]{userId, message_id,amount, status});if(count == 1) {logger.info("Ok");}return count;} } activemq.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:amq="http://activemq.apache.org/schema/core"xmlns:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.1.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.1.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms-4.1.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd"><context:component-scan base-package="com.zhuguang.jack" /><mvc:annotation-driven /><amq:connectionFactory id="amqConnectionFactory"brokerURL="tcp://192.168.88.131:61616"userName="system"password="manager" /><!-- 配置JMS连接工长 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><constructor-arg ref="amqConnectionFactory" /><property name="sessionCacheSize" value="100" /></bean><!-- 定义消息队列(Queue) --><bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue"><!-- 设置消息队列的名字 --><constructor-arg><value>zg.jack.queue</value></constructor-arg></bean><!-- 显示注入消息监听容器(Queue),配置连接工厂,监听的目标是demoQueueDestination,监听器是上面定义的监听器 --><bean id="queueListenerContainer"class="org.springframework.jms.listener.DefaultMessageListenerContainer"><property name="connectionFactory" ref="connectionFactory" /><property name="destination" ref="demoQueueDestination" /><property name="messageListener" ref="queueMessageListener" /></bean><!-- 配置JMS模板(Queue),Spring提供的JMS工具类,它发送、接收消息。 --><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="connectionFactory" /><property name="defaultDestination" ref="demoQueueDestination" /><property name="receiveTimeout" value="10000" /><!-- true是topic,false是queue,默认是false,此处显示写出false --><property name="pubSubDomain" value="false" /></bean></beans> OK~~~~~~~~~~~~大功告成!!!, 如果大家觉得满意并且对技术感兴趣请加群:171239762, 纯技术交流群,非诚勿扰。 本篇文章为转载内容。原文链接:https://blog.csdn.net/luoyang_java/article/details/84953241。 该文由互联网用户投稿提供,文中观点代表作者本人意见,并不代表本站的立场。 作为信息平台,本站仅提供文章转载服务,并不拥有其所有权,也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况,请及时联系我们,我们将第一时间进行核实并删除相应内容。
2023-04-16 22:34:52
499
转载
Java
...ait和notify实现线程同步的银行账户模型后,我们可以进一步探讨现代并发编程中的其他高级同步机制及其在实际场景中的应用。例如,Java 5引入了java.util.concurrent包,其中提供了多种高效的并发工具类,如Semaphore(信号量)、ReentrantLock(可重入锁)以及BlockingQueue(阻塞队列),它们为复杂多线程环境下的资源控制提供了更强大的支持。 具体来说,在银行账户模型中,如果考虑更多的并发操作,如转账交易,那么显式锁(如ReentrantLock)可以提供更细粒度的控制,允许公平锁、非公平锁的选择,并且具备tryLock等灵活方法,以增强系统的响应能力和处理能力。另外,通过结合使用BlockingQueue,可以构建出生产者消费者模式,有效解决线程间数据交换的问题,确保存款请求与取款请求按照先进先出(FIFO)或其他策略有序进行处理。 同时,随着JDK版本的更新,Java内存模型(JMM)的完善以及对原子变量类(AtomicInteger、AtomicLong等)的支持,使得我们能够更好地理解和利用这些底层机制优化并行计算性能,降低死锁概率,提高系统整体并发效率。 此外,对于分布式系统中的银行账户模型,还可以研究分布式锁服务(如Redis或ZooKeeper提供的分布式锁机制),以应对集群环境下多个节点间的并发控制挑战,确保全局一致性。 综上所述,尽管基于wait和notify的经典线程同步方式在特定场合下依然适用,但不断发展的Java并发库为我们提供了更多与时俱进、更为高效且功能丰富的工具,帮助开发者构建更为稳健且高性能的并发程序。
2023-09-21 14:29:58
387
电脑达人
Docker
...,这些都将进一步提升基于Docker构建的应用部署效率和安全性。 此外,随着服务网格技术如Istio、Linkerd的逐渐成熟,它们与Docker及Kubernetes的集成应用也成为业界关注焦点。通过服务网格,开发者能够更精细化地控制服务间通信,实现流量管理、熔断限流等功能,为微服务架构下的应用开发带来更强大的运维能力。 同时,针对Docker生态中的安全性问题,有专家建议开发者密切关注Docker安全实践,包括但不限于及时更新镜像、最小权限原则配置容器、使用安全扫描工具等措施。近日,Docker官方也发布了最新的安全指南,强调了如何在享受便捷高效的容器化开发环境的同时,有效降低潜在的安全风险。 综上所述,在充分利用Docker新功能提升开发效率的同时,紧跟容器技术发展趋势,并注重安全防护,将是现代软件开发工程师们的重要课题。
2023-01-08 13:18:42
491
草原牧歌_t
Go-Spring
...e配置与使用仅是众多实现方案之一,实际上,随着云原生技术的发展,新型的分布式缓存服务如Redis、Memcached以及云服务商提供的托管缓存服务也逐渐崭露头角。 近期,AWS宣布对其Amazon ElastiCache服务进行升级,提供了更为强大的内存数据库功能,支持自动扩展、多可用区部署以及数据持久化,使开发者能够更加便捷高效地构建高可用、高性能的应用。同时,Google Cloud Platform也推出了Cloud Memorystore,一款全托管的Redis和Memcached服务,旨在简化大规模Web应用和服务的数据缓存管理。 此外,对于缓存策略的设计与优化亦至关重要,比如LRU(最近最少使用)算法、LFU(最不经常使用)算法等淘汰策略的选择及应用场景分析,都是深入研究缓存技术时不可或缺的内容。因此,在实际项目开发中,结合业务特性和资源条件灵活运用并持续优化缓存机制,方能最大程度发挥其效能,为系统的整体性能保驾护航。
2023-12-01 09:24:43
447
半夏微凉-t
Docker
...题的重要工具。它能够实现服务间的智能路由、故障恢复、熔断限流等高级特性,对于运行在Docker或Kubernetes环境中的SpringBoot应用集群来说,结合Istio进行流量管理将是一个值得探索的前沿实践。 综上所述,随着容器技术和周边生态的不断发展,我们不仅需要掌握基础的Docker+Nginx部署技巧,更应关注这些技术的最新进展,以便在实际工作中应对日益复杂的微服务部署与管理挑战。
2024-01-24 15:58:35
617
柳暗花明又一村_t
MyBatis
...atchSize属性实现批量更新与删除,极大地提升了数据库操作的效率。 同时,随着云原生架构的普及,许多企业开始尝试将MyBatis与分布式缓存、数据库读写分离等技术相结合。例如,结合Redis或Memcached实现一级缓存之外的数据暂存,减少对主数据库的压力;或者根据业务场景采用分库分表策略,有效分散单一表的大数据量压力,提升查询性能。 另外,在SQL优化层面,不仅需要关注基本的索引设计、查询语句优化,还可以借助数据库自身的高级特性,如Oracle的并行查询功能,MySQL 8.0以后支持的窗口函数进行复杂分页及聚合计算等,进一步挖掘系统的性能潜力。 最后,对于微服务架构下的应用,可以通过熔断、降级、限流等手段,避免因大量并发请求导致的性能瓶颈,同时,持续监控与分析系统性能指标,结合A/B测试等方法,科学评估不同优化措施的实际效果,确保在海量数据挑战面前,系统始终保持高效稳定运行。
2023-08-07 09:53:56
56
雪落无痕
RocketMQ
...例如,书中提到了一种基于流量控制策略来防止消息堆积的方法,即通过设置合理的限流阈值和回退策略,在系统压力陡增时,既能保证核心业务不被阻塞,又能避免消息积压。此外,还介绍了如何利用RocketMQ的延迟消息功能,对非实时性要求较高的任务进行异步处理,有效缓解高峰期的压力。 同时,随着云原生技术的发展,Kubernetes等容器编排平台的应用也为消息队列提供了更灵活、高效的部署方式。阿里云RocketMQ团队已实现了与Kubernetes的深度融合,支持弹性伸缩、自动容错等功能,能够在资源利用率和消息处理能力上实现动态平衡。 总之,在面对大规模数据传输和高并发场景时,除了文中提到的基本调优手段外,结合行业前沿的最佳实践与技术创新,能够更好地确保消息队列系统的稳定性与高效性,从而为企业的业务发展保驾护航。
2023-12-19 12:01:57
51
晚秋落叶-t
Go-Spring
...越多的开发者关注到如Redis、Memcached等主流缓存解决方案在高并发场景下的实践与优化策略。例如,一篇发表在InfoQ的技术文章深入探讨了如何在Go-Spring框架下结合使用Redis集群实现分布式缓存,并通过TTL(Time To Live)机制有效管理数据过期问题,从而降低由于缓存异常引发的系统风险。 同时,也有不少研究者和开发者开始关注缓存一致性和安全性的问题。今年早些时候,一项关于缓存污染攻击的研究揭示了攻击者可能利用恶意数据导致缓存失效或误导系统行为的风险,进一步强调了在设计和使用缓存服务时,不仅要考虑性能优化,还需兼顾安全防护措施的重要性。 此外,随着Service Mesh技术的发展, Istio等服务网格解决方案提供了对缓存治理更精细的控制能力,允许开发人员在不修改应用代码的情况下,动态配置缓存策略,增强了分布式缓存管理的可观测性和可控性。 综上所述,在面对缓存服务异常问题时,除了及时发现与修复外,紧跟业界最新研究成果和技术趋势,深入了解并合理运用各类工具与最佳实践,才能确保在复杂多变的分布式环境中,我们的缓存服务能够持续稳定地发挥其提升系统性能的关键作用。
2023-11-23 18:26:05
511
心灵驿站-t
MemCache
...也在不断提升。近期,Redis等新兴的内存数据库因其支持数据持久化和主从复制等特性,逐渐成为开发者在构建高可靠分布式缓存系统时的重要选择。 例如,2022年某知名电商平台在进行架构升级时,就选择了Redis集群来替代部分Memcached服务,以解决数据易失性问题。通过Redis的AOF(Append Only File)持久化机制,该平台确保了即使在服务器宕机的情况下也能最大程度恢复缓存数据,从而极大地提升了系统的稳定性和连续性。 同时,一些云服务商如阿里云、AWS也推出了基于Redis优化的企业级缓存服务,不仅提供了自动故障切换、备份恢复等功能,还整合了多层缓存架构设计,助力企业在面对大规模并发访问时仍能保持高效的数据读取性能。 然而,值得注意的是,在引入更复杂、功能更全面的缓存解决方案时,也需要权衡其带来的额外运维成本与资源开销。因此,如何根据实际业务场景和技术栈特点,合理选用和配置缓存系统,将是每一位开发者和架构师持续探索和实践的重要课题。
2023-09-25 18:48:16
60
青山绿水
SpringCloud
...ngCloud中用于实现服务容错和隔离的重要组件。我们可以通过调整hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds属性来设定命令执行的超时时间: java // application.yml hystrix: command: default: execution: isolation: thread: timeoutInMilliseconds: 5000 设置超时时间为5秒 (2) Ribbon客户端超时配置 Ribbon是SpringCloud中的客户端负载均衡器,它允许我们为HTTP请求设置连接超时(ConnectTimeout)和读取超时(ReadTimeout): java @Configuration public class RibbonConfiguration { @Bean publicribbon: ReadTimeout: 2000 设置读取超时时间为2秒 ConnectTimeout: 1000 设置连接超时时间为1秒 } } (3) 服务端性能优化 对于服务处理耗时过长的问题,我们需要对服务进行性能优化,如数据库查询优化、缓存使用、异步处理等。例如,我们可以利用@Async注解实现异步方法调用: java @Service public class SomeService { @Async public Future timeConsumingTask() { // 这是一个耗时的操作... return new AsyncResult<>("Task result"); } } 4. 系统设计层面的思考与探讨 除了上述具体配置和优化措施外,我们也需要从系统设计角度去预防和应对超时问题。比如,咱们可以像安排乐高积木一样,把各个服务间的调用关系巧妙地搭建起来,别让它变得太绕太复杂。同时呢,咱也要像精打细算的管家,充分揣摩每个服务的“饭量”(QPS和TPS)大小,然后据此给线程池调整合适的“碗筷”数量,再定个合理的“用餐时间”(超时阈值)。再者,就像在电路中装上保险丝、开关控制电流那样,我们可以运用熔断、降级、限流这些小妙招,确保整个系统的平稳运行,随时都能稳定可靠地为大家服务。 5. 结语 总之,面对SpringCloud应用中的“超时”问题,我们应根据实际情况,采取针对性的技术手段和策略,从配置、优化和服务设计等多个维度去解决问题。这个过程啊,可以说是挑战满满,但这也恰恰是技术最吸引人的地方——就是要不断去摸索、持续改进,才能打造出一套既高效又稳定的微服务体系。就像是盖房子一样,只有不断研究和优化设计,才能最终建成一座稳固又实用的大厦。而这一切的努力,最终都会化作用户满意的微笑和体验。
2023-04-25 12:09:08
39
桃李春风一杯酒
转载文章
...的运行情况,下图为 Redis 镜像的运行日志示例: ConsoleConsole 主要为用户提供 Web Shell 操作, 这样用户日常的一些操作可直接通过 Web 进行,无需使用 SSH 工具。Console 功能如下图所示: 本篇文章为转载内容。原文链接:https://blog.csdn.net/weixin_33007357/article/details/113894561。 该文由互联网用户投稿提供,文中观点代表作者本人意见,并不代表本站的立场。 作为信息平台,本站仅提供文章转载服务,并不拥有其所有权,也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况,请及时联系我们,我们将第一时间进行核实并删除相应内容。
2023-01-24 23:58:16
217
转载
站内搜索
用于搜索本网站内部文章,支持栏目切换。
知识学习
实践的时候请根据实际情况谨慎操作。
随机学习一条linux命令:
tail -n 10 file.txt
- 显示文件结尾的10行内容。
推荐内容
推荐本栏目内的其它文章,看看还有哪些文章让你感兴趣。
2023-04-28
2023-08-09
2023-06-18
2023-04-14
2023-02-18
2023-04-17
2024-01-11
2023-10-03
2023-09-09
2023-06-13
2023-08-07
2023-03-11
历史内容
快速导航到对应月份的历史文章列表。
随便看看
拉到页底了吧,随便看看还有哪些文章你可能感兴趣。
时光飞逝
"流光容易把人抛,红了樱桃,绿了芭蕉。"