Redis基于内存非关系型数据库
生活随笔
收集整理的這篇文章主要介紹了
Redis基于内存非关系型数据库
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
Redis基于內存非關系型數據庫
Redis：非關系型數據庫介紹
特點及優點
1、開源的，使用C編寫，基于內存且支持持久化，一般內存的東東關機重啟就消失，但它不會。 2、高性能的Key-Value的NoSQL數據庫 3、支持數據類型豐富，字符串strings，散列hashes，列表lists，集合sets，有序集合sorted sets 等等 4、支持多種編程語言（C C++ Python Java PHP ... ） 5、基于內存存儲，速度很快 6、基于內存存儲，經常當作緩存型數據庫使?，常?信息緩存在redis數據庫中與其他數據庫對比
1、MySQL : 關系型數據庫，表格，基于磁盤，慢 2、MongoDB：鍵值對文檔型數據庫，值為JSON文檔，基于磁盤，慢，存儲數據類型單一 3、Redis的誕生是為了解決什么問題？？# 解決硬盤IO帶來的性能瓶頸，因為大量并發過來時，查找磁盤，速度慢，效率低，Redis基于內存的鍵值對形式，效率高，放在客戶端查詢與磁盤數據之間的緩存數據庫。應用場景
redis版本
1、最新版本：5.0 2、常用版本：2.4、2.6、2.8、3.0(里程碑加入了集群)、3.2、3.4、4.0(教學環境版本)、5.0 3、圖形界面管理工具( # 寫的一般 )RedisDesktopManagerRedis附加功能
1、持久化將內存中數據保存到磁盤中，保證數據安全，方便進行數據備份和恢復 2、過期鍵功能為鍵設置一個過期時間，讓它在指定時間內自動刪除<節省內存空間># 音樂播放器，日播放排名，過期自動刪除 3、事務功能原子的執行多個操作 4、主從復制 5、Sentinel哨兵安裝
Ubuntu
# 安裝 sudo apt-get install redis-server # 服務端啟動 sudo /etc/init.d/redis-server status | start | stop | restart # 客戶端連接 redis-cli -h IP地址 -p 6379 -a 密碼 注意：本機只寫redis-cli回車，輸入ping有回復PONG則連接成功Windows
1、下載安裝包https://github.com/ServiceStack/redis-windows/blob/master/downloads/redis-64.3.0.503.zip 2、解壓 3、啟動服務端雙擊解壓后的 redis-server.exe 4、客戶端連接雙擊解壓后的 redis-cli.exe# Windows下產生的問題：關閉終端后服務終止 # 解決方案：將Redis服務安裝到本地服務 1、重命名 redis.windows.conf 為 redis.conf,作為redis服務的配置文件 2、cmd命令行，進入到redis-server.exe所在目錄 3、執行：redis-server --service-install redis.conf --loglevel verbose 4、計算機-管理-服務-Redis-啟動# 卸載 到 redis-server.exe 所在路徑執行： 1、redis-server --service-uninstall 2、sc delete Redis配置文件詳解
配置文件所在路徑
1、Ubuntu/etc/redis/redis.confmysql的配置文件在哪里？ : /etc/mysql/mysql.conf.d/mysqld.cnf2、windows 下載解壓后的redis文件夾中redis.windows.conf redis.conf設置連接密碼
1、requirepass 密碼 2、重啟服務sudo /etc/init.d/redis-server restart 3、客戶端連接redis-cli -h 127.0.0.1 -p 6379 -a 123456127.0.0.1:6379>ping允許遠程連接
1、注釋掉本地IP地址綁定69行: # bind 127.0.0.1 ::1 2、關閉保護模式(把yes改為no)88行: protected-mode no 3、重啟服務sudo /etc/init.d/redis-server restart遠程連接測試
Windows連接Ubuntu的Redis服務
# cmd命令行 1、e: 2、cd Redis3.0 3、redis-cli -h x.x.x.x -a 123456 4、x.x.x.x:6379>ping數據類型：五大數據類型
1、字符串類型（string） 2、列表類型（list） 3、哈希類型（hash） 4、集合類型（set） 5、有序集合類型（sorted set）五大數據類型及應用場景
| string | 簡單key-value類型，value可為字符串和數字 | 常規計數（微博數, 粉絲數等功能） |
| hash | 是一個string類型的field和value的映射表，hash特別適合用于存儲對象 | 存儲部分可能需要變更的數據（比如用戶信息） |
| list | 有序可重復列表 | 關注列表，粉絲列表，消息隊列等 |
| set | 無序不可重復列表 | 存儲并計算關系（如微博，關注人或粉絲存放在集合，可通過交集、并集、差集等操作實現如共同關注、共同喜好等功能） |
| sorted set | 每個元素帶有分值的集合 | 各種排行榜 |
通用命令：適用于所有數據類型
# 切換庫(number的值在0-15之間,db0 ~ db15) select number：select 0——select 15 # 查看鍵 keys 表達式 # keys * keys na*：帶na的鍵。 # 數據類型 TYPE key：TYPE name # 鍵是否存在 exists key:exists name2,返回(integer) 1說明存在 # 刪除鍵 del key # 鍵重命名 rename key newkey # 清除當前庫中所有數據（慎用） flushdb # 清除所有庫中所有數據（慎用） flushall字符串類型(string)
特點
1、字符串、數字，都會轉為字符串來存儲 2、以二進制的方式存儲在內存中字符串常用命令
# 1. 設置一個key-value set key value #創建鍵值對數據庫內的數據存在數據庫里 set name2 li mset age 27 sex man name liu：設置多條 set name liuliu nx：信息會被其前面那一條set的內容覆蓋 # 2. 獲取key的值 get key # 3. key不存在時再進行設置(nx) set key value nx # not exists # 4. 設置過期時間(ex) set key value ex seconds set score 90 ex 5# 5. 同時設置多個key-value mset key1 value1 key2 value2 key3 value3 # 6. 同時獲取多個key-value mget key1 key2 key3字符串常用命令
# 1.獲取長度 strlen key 如：strlen name3 # 2.獲取指定范圍切片內容 getrange key start stop 如：getrange name3 0 4 # 3.從索引值開始，value替換原內容 setrange key index value 如：setrange name3 6 liu # 4.追加拼接value的值 append key value 如：append name3 li數值操作：字符串類型數字
# 整數操作 INCRBY key 步長 DECRBY key 步長 INCR key : +1操作 DECR key : -1操作 # 應用場景: 抖音上有人關注你了，是不是可以用INCR呢，如果取消關注了是不是可以用DECR # 浮點數操作: 自動先轉為數字類型，然后再進行相加減，不能使用append incrbyfloat key step 如：set salary 10000incrby salary 2000get salary"12000"decrby salary 200get salary"11800"incrbyfloat salary 1000.985get salary"12800.98500000000000032"incrbyfloat salary -1000.985get salary"11800"鍵的命名規范
? mset liu:email liuliu66@163.com
127.0.0.1:6379> mset liu:email liuliu66@163.com li:email lili@163.com OK 127.0.0.1:6379> mget liu:email li:email 1) "liuliu66@163.com" 2) "lili@163.com" 127.0.0.1:6379>string命令匯總
# 字符串操作 1、set key value 2、set key value nx 3、get key 3、mset key1 value1 key2 value2 4、mget key1 key2 key3 5、set key value nx ex seconds 6、strlen key # 返回舊值并設置新值（如果鍵不存在，就創建并賦值） 7、getset key value # 數字操作 7、incrby key 步長 8、decrby key 步長 9、incr key 10、decr key 11、incrbyfloat key number#(可為正數或負數) # 設置過期時間的兩種方式 # 方式一 1、set key value ex 3 # 方式二 1、set key value 2、expire key 5 # 秒 3、pexpire key 5 # 毫秒 # 查看存活時間 ttl key # 刪除過期 persist keystring數據類型注意
# key值取值原則 1、key值不宜過長，消耗內存，且在數據中查找這類鍵值的計算成本高 2、不宜過短，可讀性較差 # 值 1、一個字符串類型的值最多能存儲512M內容示例
1、查看 db0 庫中所有的鍵# select 0# keys * 2、設置鍵 trill:username 對應的值為 user001，并查看# set trill:username user001 3、獲取 trill:username 值的長度# strlen trill:username 4、一次性設置 trill:password 、trill:gender、trill:fansnumber 并查看（值自定義）# mset trill:password 123 trill:gender M trill:fansnumber 500 5、查看鍵 trill:score 是否存在# exists trill:score 6、增加10個粉絲# incrby trill:fansnumber 10 7、增加2個粉絲（一個一個加）# incr trill:fansnumber# incr trill:fansnumber 8、有3個粉絲取消關注你了# decrby trill:fansnumber 3 9、又有1個粉絲取消關注你了# decr trill:fansnumber 10、思考、思考、思考...,清除當前庫# flushdb 11、一萬個思考之后，清除所有庫# flushall列表數據類型（List）
特點
1、元素是字符串類型 2、列表頭尾增刪快，中間增刪慢，增刪元素是常態 3、元素可重復 4、最多可包含2^32 -1個元素 5、索引同python列表列表常用命令
# 增 1、從列表頭部壓入元素LPUSH key value1 value2 lpush teachers liu li wu hong wang lrange teachers 0 -1 1) "wang" 2) "hong" 3) "wu" 4) "li" 5) "liu" 2、從列表尾部壓入元素RPUSH key value1 value2 rpush teachers xiaoming lrange teachers 0 -11) "wang"2) "hong"3) "wu"4) "li"5) "liu"6) "wang"7) "hong"8) "wu"9) "li" 10) "xiaoming" 3、從列表src尾部彈出1個元素,壓入到列表dst的頭部RPOPLPUSH src dst rpoplpush teachers students "xiaoming" 4、在列表指定元素后/前插入元素LINSERT key after|before value newvalue # 查 5、查看列表中元素LRANGE key start stop# 查看列表中所有元素: LRANGE key 0 -1 6、獲取列表長度LLEN key # 刪 7、從列表頭部彈出1個元素LPOP key 8、從列表尾部彈出1個元素RPOP key 9、列表頭部,阻塞彈出,列表為空時阻塞BLPOP key timeout 10、列表尾部,阻塞彈出,列表為空時阻塞BRPOP key timeout# 關于BLPOP 和 BRPOP1、如果彈出的列表不存在或者為空，就會阻塞2、超時時間設置為0，就是永久阻塞，直到有數據可以彈出3、如果多個客戶端阻塞再同一個列表上，使用First In First Service原則，先到先服務 11、刪除指定元素LREM key count value lrem teachers 1 wu lrange teachers 0 -1 1) "wang" 2) "hong" 3) "li" 4) "liu" 5) "wang" 6) "hong" 7) "wu" 8) "li"count>0：表示從頭部開始向表尾搜索，移除與value相等的元素，數量為countcount<0：表示從尾部開始向表頭搜索，移除與value相等的元素，數量為countcount=0：移除表中所有與value相等的值 12、保留指定范圍內的元素LTRIM key start stopLRTIM mylist1 0 2 # 只保留前3條# 應用場景: 保存微博評論最后500條LTRIM weibo:comments 0 499 ltrim teachers 0 2 lrange teachers 0 -1 1) "wang" 2) "hong" 3) "li" # 改 13、LSET key index newvalue lset teachers 0 liu lrange teachers 0 -1 1) "liu" 2) "hong" 3) "li"示例
1、查看所有的鍵 2、向列表 spider:urls 中以RPUSH放入如下幾個元素：01_baidu.com、02_taobao.com、03_sina.com、04_jd.com、05_xxx.com 3、查看列表中所有元素 4、查看列表長度 5、將列表中01_baidu.com 改為 01_tmall.com 6、在列表中04_jd.com之后再加1個元素 02_taobao.com 7、彈出列表中的最后一個元素 8、刪除列表中所有的 02_taobao.com 9、剔除列表中的其他元素，只剩前3條 keys * #1、查看所有的鍵 1) "students" 2) "teachers" rpush spider:urls 01_baidu.com 02_taobao.com 03_sina.com 04_jd.com 05_xxx.com lrange spider:urls 0 -1 #查看列表中所有元素 1) "01_baidu.com" 2) "02_taobao.com" 3) "03_sina.com" 4) "04_jd.com" 5) "05_xxx.com" llen spider:urls #查看列表長度 (integer) 5 lset spider:urls 0 01_tmall.com lrange spider:urls 0 -1 1) "01_tmall.com" 2) "02_taobao.com" 3) "03_sina.com" 4) "04_jd.com" 5) "05_xxx.com" linsert spider:urls after 04_jd.com 02_taobao.com lrange spider:urls 0 -1 1) "01_tmall.com" 2) "02_taobao.com" 3) "03_sina.com" 4) "04_jd.com" 5) "02_taobao.com" 6) "05_xxx.com" rpop spider:urls "05_xxx.com" lrem spider:urls 0 02_taobao.com lrange spider:urls 0 -1 1) "01_tmall.com" 2) "03_sina.com" 3) "04_jd.com" ltrim spider:urls 0 1 lrange spider:urls 0 -1 1) "01_tmall.com" 2) "03_sina.com"與python交互
模塊(redis)
Ubuntu
sudo pip3 install redisWindows
# 方法1. python -m pip install redis # 方法2. 以管理員身份打開cmd命令行pip install redis使用流程
import redis # 創建數據庫連接對象 r = redis.Redis(host='127.0.0.1',port=6379,db=0,password='123456')Python與redis交互注意
1、r.set('name','Tom',ex=5,nx=True) 2、r.mset({'user1:name':'Tom','user1:age':'25'}) # 有元素時返回彈出元素,否則返回None 3、r.brpop('mylist',3)通用命令代碼示例
import redis# 創建連接對象 r = redis.Redis(host='192.168.153.146',port=6379,db=0)# r.keys('*') -> 列表 key_list = r.keys('*') for key in key_list:print(key.decode())# b'list' print(r.type('mylist')) # 返回值: 0 或者 1 print(r.exists('spider:urls')) # 刪除key r.delete('mylist2')python操作list
import redisr = redis.Redis(host='192.168.153.146',port=6379,db=0)# pylist: ['pythonweb','socket','pybase'] r.lpush('pylist','pybase','socket','pythonweb') # pylist: ['spider','pythonweb','socket','pybase'] r.linsert('pylist','before','pythonweb','spider') # 4 print(r.llen('pylist')) # [b'spider', b'pythonweb', b'socket', b'pybase'] print(r.lrange('pylist',0,-1)) # b'pybase' print(r.rpop('pylist')) # [b'spider', b'pythonweb'] r.ltrim('pylist',0,1)while True:# 如果列表中為空時,則返回Noneresult = r.brpop('pylist',1)if result:print(result)else:breakr.delete('pylist')list案例: 一個進程負責生產url，一個進程負責消費url
進程1: 生產者
import redis import time import randomr = redis.Redis(host='192.168.153.146',port=6379,db=0)# 生產者開始生產url地址 for page in range(0,67):url = 'http://app.mi.com/category/2#page=%s' % str(page)r.lpush('spider:urls',url)time.sleep(random.randint(1,3))進程2: 消費者
import redisr = redis.Redis(host='192.168.153.146',port=6379,db=0)while True:# url: (b'spider:urls',b'http://xiaomixxx')url = r.brpop('spider:urls',5)if url:print('正在抓取:',url[1].decode())else:print('抓取結束')break使用進程模塊來實現試試？
import redis import time import random from multiprocessing import Processclass Spider(object):def __init__(self):r = redis.Redis(host='192.168.153.146',port=6379,db=0)def product(self):# 生產者開始生產url地址for page in range(0,67):url = 'http://app.mi.com/category/2#page=%s' % str(page)self.r.lpush('spider:urls',url)time.sleep(random.randint(1,3))def consumer(self):while True:# url: (b'spider:urls',b'http://xiaomixxx')url = self.r.brpop('spider:urls', 5)if url:print('正在抓取:', url[1].decode())else:print('抓取結束')breakdef run(self):p1 = Process(target=self.product)p2 = Process(target=self.consumer)p1.start()p2.start()p1.join()p2.join()if __name__ == '__main__':spider = Spider()spider.run()python操作string
import redisr = redis.Redis(host='192.168.153.146',port=6379,db=0)r.set('username','guods') print(r.get('username')) # mset參數為字典 r.mset({'username':'xiaoze','password':'123456'}) # 列表: [b'xiaoze', b'123456'] print(r.mget('username','password')) # 6 print(r.strlen('username'))# 數值操作 r.set('age','25') r.incrby('age',10) r.decrby('age',10) r.incr('age') r.decr('age') r.incrbyfloat('age',3.3) r.incrbyfloat('age',-3.3) print(r.get('age'))r.delete('username')位圖操作bitmap:注:只能操作字符串
定義
1、位圖不是真正的數據類型，它是定義在字符串類型中 2、一個字符串類型的值最多能存儲512M字節的內容，位上限：2^32 # 應?場景 3、可以實時的進?數據統計（?站??的上線次數統計） # 1MB = 1024KB # 1KB = 1024Byte(字節) # 1Byte = 8bit(位)強勢點
可以實時的進行統計，極其節省空間。官方在模擬1億2千8百萬用戶的模擬環境下，在一臺MacBookPro上，典型的統計如“日用戶數”的時間消耗小于50ms, 占用16MB內存設置某一位上的值（setbit）
# 設置某一位上的值（offset是偏移量，從0開始） setbit key offset value # 獲取某一位上的值 GETBIT key offset # 統計鍵所對應的值中有多少個 1 BITCOUNT key示例
# 默認擴展位以0填充 127.0.0.1:6379> set mykey ab OK 127.0.0.1:6379> get mykey "ab" 127.0.0.1:6379> SETBIT mykey 0 1 (integer) 0 127.0.0.1:6379> get mykey "\xe1b" 127.0.0.1:6379>獲取某一位上的值
GETBIT key offset
127.0.0.1:6379> GETBIT mykey 3 (integer) 0 127.0.0.1:6379> GETBIT mykey 0 (integer) 1 127.0.0.1:6379>bitcount
統計鍵所對應的值中有多少個 1
127.0.0.1:6379> SETBIT user001 1 1 (integer) 0 127.0.0.1:6379> SETBIT user001 30 1 (integer) 0 127.0.0.1:6379> bitcount user001 (integer) 2 127.0.0.1:6379>應用場景案例
# 網站用戶的上線次數統計（尋找活躍用戶）用戶名為key，上線的天作為offset，上線設置為1 # 示例用戶名為 user1:login 的用戶，今年第1天上線，第30天上線SETBIT user1:login 0 1 SETBIT user1:login 29 1BITCOUNT user1:login代碼實現
import redisr = redis.Redis(host='127.0.0.1',port=6379,db=0)# user001: 一年中第5天和200天登錄 r.setbit('user:001',4,1) r.setbit('user:001',199,1) # user002: 一年中第100天和第300天登錄 r.setbit('user:002',99,1) r.setbit('user:002',299,1) # user:003: 登錄了100次以上 for i in range(1,366,2):r.setbit('user:003',i,1) # user:004: 登錄了100次以上 for i in range(1,366,3):r.setbit('user:004',i,1)user_list = r.keys('user:*')# 存放活躍用戶列表 active_users = [] # 存放不活躍用戶列表 no_active_users = []for user in user_list:login_count = r.bitcount(user)if login_count >= 100:active_users.append((user,login_count))else:no_active_users.append((user,login_count))print('活躍用戶:',active_users) print('不活躍用戶:',no_active_users)Hash散列數據類型
定義
1、由field和關聯的value組成的鍵值對 2、field和value是字符串類型 3、一個hash中最多包含2^32-1個鍵值對優點
1、節約內存空間 2、每創建一個鍵，它都會為這個鍵儲存一些附加的管理信息（比如這個鍵的類型，這個鍵最后一次被訪問的時間等） 3、鍵越多，redis數據庫在儲存附件管理信息方面耗費內存越多，花在管理數據庫鍵上的CPU也會越多 # 應?場景 4、很適合存儲對象類型，?如說??ID作為key，??的所有屬性及值作為key對應的value（??維度統計-各種數據統計-發帖數、粉絲數等）缺點（不適合hash情況）
1、使用二進制位操作命令:SETBIT、GETBIT、BITCOUNT等，如果想使用這些操作，只能用字符串鍵 2、使用過期鍵功能：鍵過期功能只能對鍵進行過期操作，而不能對散列的字段進行過期操作基本命令操作
# 1、設置單個字段 HSET key field value HSETNX key field value # 2、設置多個字段 HMSET key field value field value # 3、返回字段個數 HLEN key # 4、判斷字段是否存在（不存在返回0） HEXISTS key field # 5、返回字段值 HGET key field # 6、返回多個字段值 HMGET key field filed # 7、返回所有的鍵值對 HGETALL key # 8、返回所有字段名 HKEYS key # 9、返回所有值 HVALS key # 10、刪除指定字段 HDEL key field # 11、在字段對應值上進行整數增量運算 HINCRBY key filed increment # 12、在字段對應值上進行浮點數增量運算 HINCRBYFLOAT key field incrementHash與python交互
# 1、更新一條數據的屬性，沒有則新建 hset(name, key, value) 即hset(key,filed,value) # 2、讀取這條數據的指定屬性， 返回字符串類型 hget(name, key) # 3、批量更新數據（沒有則新建）屬性,參數為字典 hmset(name, mapping) # 4、批量讀取數據（沒有則新建）屬性 hmget(name, keys) # 5、獲取這條數據的所有屬性和對應的值，返回字典類型 hgetall(name) # 6、獲取這條數據的所有屬性名，返回列表類型 hkeys(name) # 7、刪除這條數據的指定屬性 hdel(name, *keys)Python代碼hash散列
'''設置1個字段,更改1個字段,設置多個字段,獲取相關信息''' import redisr = redis.Redis(host='127.0.0.1',port=6379,db=0) # 設置 r.hset('user1','name','bujingyun') # 更新 r.hset('user1','name','kongci') # 取數據 print(r.hget('user1','name')) # 一次設置多個field和value user_dict = {'password':'123456','gender':'F','height':'165' } r.hmset('user1',user_dict) # 獲取所有數據,字典 print(r.hgetall('user1'))# 獲取所有fields和所有values print(r.hkeys('user1')) print(r.hvals('user1'))應用場景：微博好友關注
1、用戶ID為key，Field為好友ID，Value為關注時間key field valueuser:10000 user:606 20190520user:605 20190521 2、用戶維度統計統計數包括：關注數、粉絲數、喜歡商品數、發帖數用戶為key，不同維度為field，value為統計數比如關注了5人HSET user:10000 fans 5HINCRBY user:10000 fans 1應用場景: redis+mysql+hash組合使用
原理
用戶想要查詢個人信息 1、到redis緩存中查詢個人信息 2、redis中查詢不到，到mysql查詢，` 3、再次查詢個人信息代碼實現
import redis import pymysql# 1. 先到redis中查詢 # 2. redis中沒有,到mysql查詢,緩存到redis(設置過期時間) # 3. 再查詢1次 r = redis.Redis(host='192.168.153.148',port=6379,db=0) username = input('請輸入用戶名:')result = r.hgetall(username) if result:print(result) else:# redis中沒有緩存,需要到mysql中查詢db = pymysql.connect(host='192.168.153.148',user='tiger',password='123456',database='userdb',charset='utf8')cursor = db.cursor()sele = 'select age,gender from user where username=%s'cursor.execute(sele,[username])# userinfo: (('guoxiaonao',36,'M'),)userinfo = cursor.fetchall()if not userinfo:print('用戶不存在')else:# 打印輸出print('mysql',userinfo)# 緩存到redisuser_dict = {'age':userinfo[0][0],'gender':userinfo[0][1]}r.hmset(username,user_dict)# 設置過期時間r.expire(username,30)mysql數據庫中數據更新信息后同步到redis緩存
用戶修改個人信息時，要將數據同步到redis緩存
import redis import pymysqlclass Update(object):def __init__(self):self.db = pymysql.connect('127.0.0.1', 'root', '123456','userdb', charset='utf8')self.cursor = self.db.cursor()self.r = redis.Redis(host='127.0.0.1', port=6379, db=0)# 更新mysql表記錄def update_mysql(self,score,username):upd = 'update user set score=%s where name=%s'try:self.cursor.execute(upd,[score,username])self.db.commit()return Trueexcept Exception as e:self.db.rollback()print('Failed',e)# 同步到redis數據庫def update_redis(self,username,score):result = self.r.hgetall(username)# 存在,更新score字段的值# 不存在,緩存整個用戶信息if result:self.r.hset(username,'score',score)else:# 到mysql中查詢最新數據,緩存到redis中self.select_mysql(username)#def select_mysql(self,username):sel = 'select age,gender,score from user where name=%s'self.cursor.execute(sel,[username])result = self.cursor.fetchall()# 緩存到redis數據庫user_dict = {'age' : result[0][0],'gender' : result[0][1],'score' : result[0][2]}self.r.hmset(username,user_dict)self.r.expire(username,60)def main(self):username = input('請輸入用戶名:')new_score = input('請輸入新成績:')if self.update_mysql(new_score,username):self.update_redis(username,new_score)else:print('更改信息失敗')if __name__ == '__main__':syn = Update()syn.main()集合數據類型（set）
特點
1、無序、去重 2、元素是字符串類型 3、最多包含2^32-1個元素 # 應?場景 4、共同關注、共同好友基本命令
# 1、增加一個或者多個元素,自動去重 SADD key member1 member2 # 2、查看集合中所有元素 SMEMBERS key # 3、刪除一個或者多個元素，元素不存在自動忽略 SREM key member1 member2 # 4、元素是否存在 SISMEMBER key member # 5、隨機返回集合中指定個數的元素，默認為1個 SRANDMEMBER key [count] # 6、彈出成員 SPOP key [count] # 7、返回集合中元素的個數，不會遍歷整個集合，只是存儲在鍵當中了 SCARD key # 8、把元素從源集合移動到目標集合 SMOVE source destination member# 9、差集(number1 1 2 3 number2 1 2 4 結果為3) SDIFF key1 key2 # 10、差集保存到另一個集合中 SDIFFSTORE destination key1 key2# 11、交集 SINTER key1 key2 SINTERSTORE destination key1 key2# 11、并集 SUNION key1 key2 SUNIONSTORE destination key1 key2案例: 新浪微博的共同關注
# 需求: 當用戶訪問另一個用戶的時候，會顯示出兩個用戶共同關注過哪些相同的用戶 # 設計: 將每個用戶關注的用戶放在集合中，求交集即可 # 實現:user001 = {'peiqi','qiaozhi','danni'}user002 = {'peiqi','qiaozhi','lingyang'}user001和user002的共同關注為:SINTER user001 user002結果為: {'peiqi','qiaozhi'}python操作set
# 1、給name對應的集合中添加元素 sadd(name,values) r.sadd("set_name","tom") r.sadd("set_name","tom","jim")# 2、獲取name對應的集合的所有成員: python集合 smembers(name) r.smembers('set_name')# 3、獲取name對應的集合中的元素個數 scard(name) r.scard("set_name")# 4、檢查value是否是name對應的集合內的元素:True|False sismember(name, value) r.sismember('set_name','tom')# 5、隨機刪除并返回指定集合的一個元素 spop(name) member = r.spop('set_name')# 6、刪除集合中的某個元素 srem(name, value) r.srem("set_name", "tom")# 7、獲取多個name對應集合的交集 sinter(keys, *args)r.sadd("set_name","a","b") r.sadd("set_name1","b","c") r.sadd("set_name2","b","c","d")print(r.sinter("set_name","set_name1","set_name2")) #輸出:｛b'b'｝# 8、獲取多個name對應的集合的并集: python集合 sunion(keys, *args) r.sunion("set_name","set_name1","set_name2")python代碼實現微博關注
import redisr = redis.Redis(host='127.0.0.1',port=6379,db=0)# user1關注的人 r.sadd('user1:focus','peiqi','qiaozhi','danni') # user2關注的人 r.sadd('user2:focus','peiqi','qiaozhi','lingyang') # 共同關注: 求交集 {b'qiaozhi', b'peiqi'} focus_set = r.sinter('user1:focus','user2:focus')# 創建空集合,存放最終結果 result = set()for focus in focus_set:result.add(focus.decode())print(result)有序集合sortedset:主要運用:排行榜
特點
1、有序、去重 2、元素是字符串類型 3、每個元素都關聯著一個浮點數分值(score)，并按照分值從小到大的順序排列集合中的元素（分值可以相同） 4、最多包含2^32-1元素 # 應?場景 5、各種排?榜 6、游戲：列出前100名?分選? 7、列出某??當前的全球排名 8、各種?排?榜、周排?榜、?排?榜示例
一個保存了水果價格的有序集合
| 元素 | 西瓜 | 葡萄 | 芒果 | 香蕉 | 蘋果 |
一個保存了員工薪水的有序集合
| 元素 | lucy | tom | jim | jack |
一個保存了正在閱讀某些技術書的人數
| 元素 | 核心編程 | 阿凡提 | 本拉登 | 阿姆斯特朗 | 比爾蓋茨 |
有序集合常用命令
# 在有序集合中添加一個成員 zadd key score member（即數字在前） 如：zadd age4 27 liu 25 li 26 wu 30 hong # 查看指定區間元素（升序) zrange key start stop [withscores] 如：zrange age4 0 -1 withscores # 查看指定區間元素（降序） ZREVRANGE key start stop [withscores] # 查看指定元素的分值 ZSCORE key member 如：zscore age4 li# 返回指定區間元素 # offset : 跳過多少個元素 # count : 返回幾個 # 小括號 : 開區間 zrangebyscore fruits (2.0 8.0 zrangebyscore key min max [withscores] [limit offset count] # 每頁顯示10個成員,顯示第5頁的成員信息: # limit 40 10 # MySQL: 每頁顯示10條記錄,顯示第5頁的記錄 # limit 40,10 # limit 2,3 顯示: 第3 4 5條記錄# 刪除成員 zrem key member # 增加或者減少分值 zincrby key increment member # 返回元素排名 zrank key member # 返回元素逆序排名 zrevrank key member # 刪除指定區間內的元素 zremrangebyscore key min max # 返回集合中元素個數 zcard key # 返回指定范圍中元素的個數 zcount key min max zcount salary 6000 8000 zcount salary (6000 8000# 6000<salary<=8000 zcount salary (6000 (8000#6000<salary<8000 # 并集 zunionstore destination numkeys key [weights 權重值] [AGGREGATE SUM|MIN|MAX] # zunionstore salary3 2 salary salary2 weights 1 0.5 AGGREGATE MAX # 2代表集合數量,weights之后 權重1給salary,權重0.5給salary2集合,算完權重之后執行聚合AGGREGATE# 交集：和并集類似，只取相同的元素 ZINTERSTORE destination numkeys key1 key2 WEIGHTS weight AGGREGATE SUM(默認)|MIN|MAXpython操作sorted set
import redisr = redis.Redis(host='127.0.0.1',port=6379,db=0) # 注意第二個參數為字典 # 命令行:zadd salary 6000 tom 8000 jim r.zadd('salary',{'tom':6000,'jim':8000,'jack':12000}) # 結果為列表中存放元組[(),(),()] print(r.zrange('salary',0,-1,withscores=True)) # 命令行:zrang salary 0 -1 withscores print(r.zrevrange('salary',0,-1,withscores=True)) # start:起始值,num:顯示條數 print(r.zrangebyscore('salary',6000,12000,start=1,num=2,withscores=True)) #命令行：zrangebyscore salary 6000 12000 withscores limit 1 2 # 刪除 r.zrem('salary','tom') #命令行：zrem salary tom print(r.zrange('salary',0,-1,withscores=True)) # 增加分值 r.zincrby('salary',5000,'jack') #命令行：zincrby salary 200 jack print(r.zrange('salary',0,-1,withscores=True)) # 返回元素排名 print(r.zrank('salary','jack')) #命令行：zrank salary jack print(r.zrevrank('salary','jack')) # 刪除指定區間內的元素 r.zremrangebyscore('salary',6000,8000) #命令行：zremrangebyscore salary 6000 8000 print(r.zrange('salary',0,-1,withscores=True)) # 統計元素個數 print(r.zcard('salary')) #命令行：zcard salary # 返回指定范圍內元素個數 print(r.zcount('salary',6000,20000)) #命令行：zcount salary 6000 20000 # 并集 r.zadd('salary2',{'jack':17000,'lucy':8000}) r.zunionstore('salary3',('salary','salary2'),aggregate='max') print(r.zrange('salary3',0,-1,withscores=True)) # 交集 r.zinterstore('salary4',('salary','salary2'),aggregate='max') print(r.zrange('salary4',0,-1,withscores=True))有序集合的交集與并集
# 交集（weights代表權重值，aggregate代表聚合方式 - 先計算權重值，然后再聚合） ZINTERSTORE destination numkeys key1 key2 WEIGHTS weight AGGREGATE SUM|MIN|MAX # 并集（weights代表權重值，aggregate代表聚合方式 - 先計算權重值，然后再聚合） ZUNIONSTORE destination numkeys key [weights 權重值] [AGGREGATE SUM|MIN|MAX]案例1：網易音樂排行榜
1、每首歌的歌名作為元素 2、每首歌的播放次數作為分值 3、使用ZREVRANGE來獲取播放次數最多的歌曲代碼實現
import redisr = redis.Redis(host='127.0.0.1',port=6379,db=0)# 有序集合中添加了8首歌曲 r.zadd('ranking',{'song1':1,'song2':1,'song3':1,'song4':1}) r.zadd('ranking',{'song5':1,'song6':1,'song7':1,'song8':1}) # 指定成員增加分值 r.zincrby('ranking',50,'song3') r.zincrby('ranking',60,'song4') r.zincrby('ranking',70,'song8') # 獲取前3名: [('song8',71),(),()] rlist = r.zrevrange('ranking',0,2,withscores=True)i = 1 for name in rlist:print('第{}名:{} 播放次數:{}'.format(i,name[0].decode(),int(name[1])))i += 1# 第1名:song8 播放次數:71# 第2名:song4 播放次數:61# 第3名:song3 播放次數:51案例2: 京東商品暢銷榜
# 第1天 ZADD mobile-001 5000 'huawei' 4000 'oppo' 3000 'iphone' # 第2天 ZADD mobile-002 5200 'huawei' 4300 'oppo' 3230 'iphone' # 第3天 ZADD mobile-003 5500 'huawei' 4660 'oppo' 3580 'iphone' 問題：如何獲取三款手機的銷量排名？ ZUNIONSTORE mobile-001:003 mobile-001 mobile-002 mobile-003 # 可否？ # 正確 方法1: ZRANGE mobile-003 0 -1 WITHSCORES 方法2: ZUNIONSTORE mobile-001:003 3 mobile-001 mobile-002 mobile-003 AGGREGATE MAXpython代碼實現
import redisr = redis.Redis(host='127.0.0.1',port=6379,db=0)day01_dict = {'huawei':5000,'oppo':4000,'iphone':3000 } day02_dict = {'huawei':5200,'oppo':4300,'iphone':3230 } day03_dict = {'huawei':5500,'oppo':4400,'iphone':3600 }r.zadd('mobile-001',day01_dict) r.zadd('mobile-002',day02_dict) r.zadd('mobile-003',day03_dict)# 并集,第二個參數為元組 r.zunionstore('mobile-001:003',('mobile-001','mobile-002','mobile-003'),aggregate='max' ) # 逆序:[(),(),()] rlist = r.zrevrange('mobile-001:003',0,2,withscores=True)for r in rlist:print('{}-{}'.format(r[0].decode(),int(r[1])))數據持久化
持久化定義
將數據從掉電易失的內存放到永久存儲的設備上為什么需要持久化
因為所有的數據都在內存上，所以必須得持久化數據持久化分類之 - RDB模式（默認開啟）
默認模式
1、保存真實的數據 2、將服務器包含的所有數據庫數據以二進制文件的形式保存到硬盤里面 3、默認文件名 ：/var/lib/redis/dump.rdb創建rdb文件的兩種方式
**方式一：**服務器執行客戶端發送的SAVE或者BGSAVE命令
127.0.0.1:6379> SAVE備份效率比bgsave高，但bgsave常用，因為save會阻塞。 OK # 特點 1、執行SAVE命令過程中，redis服務器將被阻塞，無法處理客戶端發送的命令請求，在SAVE命令執行完畢后，服務器才會重新開始處理客戶端發送的命令請求 2、如果RDB文件已經存在，那么服務器將自動使用新的RDB文件代替舊的RDB文件 # 工作中定時持久化保存一個文件127.0.0.1:6379> BGSAVE Background saving started # 執行過程如下 1、客戶端 發送 BGSAVE 給服務器 2、服務器馬上返回 Background saving started 給客戶端 3、服務器 fork() 子進程做這件事情 4、服務器繼續提供服務 5、子進程創建完RDB文件后再告知Redis服務器# 配置文件相關操作 sudo -i cd /var/lib/redis/ vi /etc/redis/redis.conf /etc/mysql/mysql.conf.d/mysqld.cnf 263行: dir /var/lib/redis # 表示rdb文件存放路徑 253行: dbfilename dump.rdb # 文件名# 兩個命令比較 SAVE比BGSAVE快，因為需要創建子進程，消耗額外的內存# 補充：可以通過查看日志文件來查看redis都做了哪些操作 # 日志文件：配置文件中搜索 logfile logfile /var/log/redis/redis-server.log**方式二：設置配置文件條件滿足時自動保存（使用最多）**執行的是bgsave
# 命令行示例 redis>save 300 10表示如果距離上一次創建RDB文件已經過去了300秒，并且服務器的所有數據庫總共已經發生了不少于10次修改，那么自動執行BGSAVE命令 redis>save 60 10000表示如果距離上一次創建rdb文件已經過去60秒，并且服務器所有數據庫總共已經發生了不少于10000次修改，那么執行bgsave命令# redis配置文件默認 218行: save 900 1 219行: save 300 10 220行: save 60 100001、只要三個條件中的任意一個被滿足時，服務器就會自動執行BGSAVE2、每次創建RDB文件之后，服務器為實現自動持久化而設置的時間計數器和次數計數器就會被清零，并重新開始計數，所以多個保存條件的效果不會疊加數據持久化分類之 - AOF（AppendOnlyFile，默認未開啟）
特點
1、存儲的是命令，而不是真實數據 2、默認不開啟 # 開啟方式（修改配置文件） 1、/etc/redis/redis.conf672行: appendonly yes # 把 no 改為 yes676行: appendfilename "appendonly.aof" 2、重啟服務sudo /etc/init.d/redis-server restartRDB缺點
1、創建RDB文件需要將服務器所有的數據庫的數據都保存起來，這是一個非常消耗資源和時間的操作，所以服務器需要隔一段時間才創建一個新的RDB文件，也就是說，創建RDB文件不能執行的過于頻繁，否則會嚴重影響服務器的性能 2、可能丟失數據AOF持久化原理及優點
# 原理1、每當有修改數據庫的命令被執行時，服務器就會將執行的命令寫入到AOF文件的末尾2、因為AOF文件里面存儲了服務器執行過的所有數據庫修改的命令，所以給定一個AOF文件，服務器只要重新執行一遍AOF文件里面包含的所有命令，就可以達到還原數據庫的目的# 優點用戶可以根據自己的需要對AOF持久化進行調整，讓Redis在遭遇意外停機時不丟失任何數據，或者只丟失一秒鐘的數據，這比RDB持久化丟失的數據要少的多安全性問題考慮
# 因為雖然服務器執行一個修改數據庫的命令，就會把執行的命令寫入到AOF文件，但這并不意味著AOF文件持久化不會丟失任何數據，在目前常見的操作系統中，執行系統調用write函數，將一些內容寫入到某個文件里面時，為了提高效率，系統通常不會直接將內容寫入硬盤里面，而是將內容放入一個內存緩存區（buffer）里面，等到緩沖區被填滿時才將存儲在緩沖區里面的內容真正寫入到硬盤里# 所以1、AOF持久化：當一條命令真正的被寫入到硬盤里面時，這條命令才不會因為停機而意外丟失2、AOF持久化在遭遇停機時丟失命令的數量，取決于命令被寫入到硬盤的時間3、越早將命令寫入到硬盤，發生意外停機時丟失的數據就越少，反之亦然策略 - 配置文件
# 打開配置文件:/etc/redis/redis.conf，找到相關策略如下 1、701行: alwarys服務器每寫入一條命令，就將緩沖區里面的命令寫入到硬盤里面，服務器就算意外停機，也不會丟失任何已經成功執行的命令數據 2、702行: everysec（# 默認）服務器每一秒將緩沖區里面的命令寫入到硬盤里面，這種模式下，服務器即使遭遇意外停機，最多只丟失1秒的數據 3、703行: no服務器不主動將命令寫入硬盤,由操作系統決定何時將緩沖區里面的命令寫入到硬盤里面，丟失命令數量不確定# 運行速度比較 always：速度慢 everysec和no都很快，默認值為everysecAOF文件中是否會產生很多的冗余命令？
為了讓AOF文件的大小控制在合理范圍，避免胡亂增長，redis提供了AOF重寫功能，通過這個功能，服務器可以產生一個新的AOF文件-- 新的AOF文件記錄的數據庫數據和原由的AOF文件記錄的數據庫數據完全一樣-- 新的AOF文件會使用盡可能少的命令來記錄數據庫數據，因此新的AOF文件的提及通常會小很多-- AOF重寫期間，服務器不會被阻塞，可以正常處理客戶端發送的命令請求示例
| select 0 | SELECT 0 |
| sadd myset peiqi | SADD myset peiqi qiaozhi danni lingyang |
| sadd myset qiaozhi | SET msg ‘hello tarena’ |
| sadd myset danni | RPUSH mylist 2 3 5 |
| sadd myset lingyang | |
| INCR number | |
| INCR number | |
| DEL number | |
| SET message ‘hello world’ | |
| SET message ‘hello tarena’ | |
| RPUSH mylist 1 2 3 | |
| RPUSH mylist 5 | |
| LPOP mylist |
AOF文件重寫方法觸發
1、客戶端向服務器發送BGREWRITEAOF命令127.0.0.1:6379> BGREWRITEAOFBackground append only file rewriting started2、修改配置文件讓服務器自動執行BGREWRITEAOF命令743行：auto-aof-rewrite-percentage 100744行：auto-aof-rewrite-min-size 64mb# 解釋1、只有當AOF文件的增量大于100%時才進行重寫，也就是大一倍的時候才觸發# 第一次重寫新增：64M# 第二次重寫新增：128M# 第三次重寫新增：256M（新增128M）RDB和AOF持久化對比
| 全量備份，一次保存整個數據庫 | 增量備份，一次保存一個修改數據庫的命令 |
| 保存的間隔較長 | 保存的間隔默認為一秒鐘 |
| 數據還原速度快 | 數據還原速度一般，冗余命令多，還原速度慢 |
| 執行SAVE命令時會阻塞服務器，但手動或者自動觸發的BGSAVE不會阻塞服務器 | 無論是平時還是進行AOF重寫時，都不會阻塞服務器 |
數據恢復（無需手動操作）
既有dump.rdb，又有appendonly.aof，恢復時找誰？ 先找appendonly.aof配置文件常用配置總結
# 設置密碼 1、requirepass password # 開啟遠程連接 2、bind 127.0.0.1 ::1 注釋掉 3、protected-mode no 把默認的 yes 改為 no # rdb持久化-默認配置 4、dbfilename 'dump.rdb' 5、dir /var/lib/redis # rdb持久化-自動觸發(條件) 6、save 900 1 7、save 300 10 8、save 60 10000 # aof持久化開啟 9、appendonly yes 10、appendfilename 'appendonly.aof' # aof持久化策略 11、appendfsync always 12、appendfsync everysec # 默認 13、appendfsync no # aof重寫觸發 14、auto-aof-rewrite-percentage 100 15、auto-aof-rewrite-min-size 64mb # 設置為從服務器 16、salveof <master-ip> <master-port>Redis相關文件存放路徑
1、配置文件: /etc/redis/redis.conf 2、備份文件: /var/lib/redis/*.rdb|*.aof 3、日志文件: /var/log/redis/redis-server.log 4、啟動文件: /etc/init.d/redis-server # /etc/下存放配置文件 # /etc/init.d/下存放服務啟動文件Redis主從復制
定義
1、一個Redis服務可以有多個該服務的復制品，這個Redis服務成為master，其他復制品成為slaves 2、master會一直將自己的數據更新同步給slaves，保持主從同步 3、只有master可以執行寫命令，slave只能執行讀命令作用
分擔了讀的壓力（高并發）原理
從服務器執行客戶端發送的讀命令，比如GET、LRANGE、SMEMMBERS、HGET、ZRANGE等等，客戶端可以連接slaves執行讀請求，來降低master的讀壓力兩種實現方式
方式一（Linux命令行實現1）
redis-server --slaveof
# 從服務端 redis-server --port 6300 --slaveof 127.0.0.1 6379 # 從客戶端 redis-cli -p 6300 127.0.0.1:6300> keys * # 發現是復制了原6379端口的redis中數據 127.0.0.1:6300> set mykey 123 (error) READONLY You can't write against a read only slave. 127.0.0.1:6300> # 從服務器只能讀數據，不能寫數據方式一（Redis命令行實現2）
# 兩條命令 1、>slaveof IP PORT 2、>slaveof no one示例
# 服務端啟動 redis-server --port 6301 # 客戶端連接 tarena@tedu:~$ redis-cli -p 6301 127.0.0.1:6301> keys * 1) "myset" 2) "mylist" 127.0.0.1:6301> set mykey 123 OK # 切換為從 127.0.0.1:6301> slaveof 127.0.0.1 6379 OK 127.0.0.1:6301> set newkey 456 (error) READONLY You can't write against a read only slave. 127.0.0.1:6301> keys * 1) "myset" 2) "mylist" # 再切換為主 127.0.0.1:6301> slaveof no one OK 127.0.0.1:6301> set name hello OK方式二(修改配置文件)
# 每個redis服務,都有1個和他對應的配置文件 # 兩個redis服務1、6379 -> /etc/redis/redis.conf2、6300 -> /home/tarena/redis_6300.conf# 修改配置文件 vi redis_6300.conf slaveof 127.0.0.1 6379 port 6300 # 啟動redis服務 redis-server redis_6300.conf # 客戶端連接測試 redis-cli -p 6300 127.0.0.1:6300> hset user:1 username guods (error) READONLY You can't write against a read only slave.問題總結：master掛了怎么辦？
1、一個Master可以有多個Slaves 2、Slave下線，只是讀請求的處理性能下降 3、Master下線，寫請求無法執行 4、其中一臺Slave使用SLAVEOF no one命令成為Master，其他Slaves執行SLAVEOF命令指向這個新的Master，從它這里同步數據 # 以上過程是手動的，能夠實現自動，這就需要Sentinel哨兵，實現故障轉移Failover操作示例
1、啟動端口6400redis，設置為6379的slaveredis-server --port 6400redis-cli -p 6400redis>slaveof 127.0.0.1 6379 2、啟動端口6401redis，設置為6379的slaveredis-server --port 6401redis-cli -p 6401redis>slaveof 127.0.0.1 6379 3、關閉6379redissudo /etc/init.d/redis-server stop 4、把6400redis設置為masterredis-cli -p 6401redis>slaveof no one 5、把6401的redis設置為6400redis的salveredis-cli -p 6401redis>slaveof 127.0.0.1 6400 # 這是手動操作，效率低，而且需要時間，有沒有自動的？？？官方高可用方案Sentinel
Redis之哨兵 - sentinel
1、Sentinel會不斷檢查Master和Slaves是否正常 2、每一個Sentinel可以監控任意多個Master和該Master下的Slaves示例
1、環境搭建
# 共3臺redis的服務器，如果是不同機器端口號可以是一樣的 1、啟動6379的redis服務器sudo /etc/init.d/redis-server start 2、啟動6380的redis服務器，設置為6379的從redis-server --port 6380tarena@tedu:~$ redis-cli -p 6380127.0.0.1:6380> slaveof 127.0.0.1 6379OK 3、啟動6381的redis服務器，設置為6379的從redis-server --port 6381tarena@tedu:~$ redis-cli -p 6381127.0.0.1:6381> slaveof 127.0.0.1 63792、安裝并搭建sentinel哨兵
# 1、安裝redis-sentinel sudo apt install redis-sentinel 驗證: sudo /etc/init.d/redis-sentinel stop # 2、新建配置文件sentinel.conf port 26379 Sentinel monitor tedu 127.0.0.1 6379 1# 3、啟動sentinel 方式一: redis-sentinel sentinel.conf 方式二: redis-server sentinel.conf --sentinel#4、將master的redis服務終止，查看從是否會提升為主 sudo /etc/init.d/redis-server stop # 發現提升6381為master，其他兩個為從 # 在6381上設置新值，6380查看 127.0.0.1:6381> set name tedu OK# 啟動6379，觀察日志，發現變為了6381的從 主從+哨兵基本就夠用了sentinel.conf解釋
# sentinel監聽端口，默認是26379，可以修改 port 26379 # 告訴sentinel去監聽地址為ip:port的一個master，這里的master-name可以自定義，quorum是一個數字，指明當有多少個sentinel認為一個master失效時，master才算真正失效 sentinel monitor <master-name> <ip> <redis-port> <quorum>生產環境中設置哨兵sentinel
1、安裝sentinelsudo apt-get install redis-sentinel 2、創建配置文件 sentinel.confport 26379Sentinel monitor 名字 IP PORT 投票數 3、啟動sentinel開始監控redis-sentinel sentinel.conf分布式鎖
高并發產生的問題？
1、購票: 多個用戶搶到同一張票？ 2、購物: 庫存只剩1個,被多個用戶成功買到？ ... ...怎么辦？
在不同進程需要互斥地訪問共享資源時，分布式鎖是一種非常有用的技術手段原理
1、多個客戶端先到redis數據庫中獲取一把鎖,得到鎖的用戶才可以操作數據庫 2、此用戶操作完成后釋放鎖，下一個成功獲取鎖的用戶再繼續操作數據庫實現
set key value nx ex 3 # 見圖: 分布式鎖原理.png博客項目解決高并發問題
1、在數據庫中創建庫 blog，指定字符編碼utf8
mysql -uroot -p123456 mysql>create database blog charset utf8;2、同步數據庫，并在user_profile中插入表記錄
1、python3 manage.py makemigrations 2、python3 manage.py migrate 3、insert into user_profile values ('guoxiaonao','guoxiaonao','guoxiaonao@tedu.cn','123456','aaaaaaaa','bbbbbbbb','cccccccc');3、啟動django項目，并找到django路由測試 test函數
1、python3 manage.py runserver 2、查看項目的 urls.py 路由，打開firefox瀏覽器輸入地址：http://127.0.0.1:8000/test/ # 返回結果： {"code": 200}4、在數據庫表中創建測試字段score
1、user/models.py添加:score = models.IntegerField(verbose_name=u'分數',null=True,default=0) 2、同步到數據庫python3 manage.py makemigrations userpython3 manage.py migrate user 3、到數據庫中確認查看3、在blog/views.py中補充 test函數，對數據庫中score字段進行 +1 操作
from user.models import UserProfile def test(request):u = UserProfile.objects.get(username='guoxiaonao')u.score += 1u.save()return JsonResponse('HI HI HI')4、啟多個服務端，模擬30個并發請求
(1)多臺服務器啟動項目
python3 manage.py runserver 127.0.0.1:8000 python3 manage.py runserver 127.0.0.1:8001(2)在tools中新建py文件 test_api.py，模擬30個并發請求
import threading import requests import randomdef getRequest():url='http://127.0.0.1:8000/test/'url2='http://127.0.0.1:8001/test/'get_url = random.choice([url, url2])requests.get(get_url)ts = [] for i in range(30):t=threading.Thread(target=getRequest,args=())ts.append(t)if __name__ == '__main__':for t in ts:t.start()for t in ts:t.join()(3) python3 test_api.py
(4) 在數據庫中查看 score 字段的值
并沒有+30，而且沒有規律，每次加的次數都不同，如何解決？？？解決方案：redis分布式鎖
jiudef test(request):# 解決方法二:redis分布式鎖import redispool = redis.ConnectionPool(host='localhost', port=6379, db=0)r = redis.Redis(connection_pool=pool)while True:try:with r.lock('guoxiaonao', blocking_timeout=3) as lock:u = UserProfile.objects.get(username='guoxiaonao')u.score += 1u.save()breakexcept Exception as e:print('lock is failed')return HttpResponse('HI HI HI')Redis事務
特點
1. 單獨的隔離操作：事務中的所有命令會被序列化、按順序執行，在執行的過程中不會被其他客戶端發送來的命令打斷 2. 不保證原子性：redis中的一個事務中如果存在命令執行失敗，那么其他命令依然會被執行，沒有回滾機制事務命令
1、MULTI # 開啟事務 2、命令1 # 執行命令 3、命令2 ... ... 4、EXEC # 提交到數據庫執行 4、DISCARD # 取消事務使用步驟
# 開啟事務 127.0.0.1:6379> MULTI OK # 命令1入隊列 127.0.0.1:6379> INCR n1 QUEUED # 命令2入隊列 127.0.0.1:6379> INCR n2 QUEUED # 提交到數據庫執行 127.0.0.1:6379> EXEC 1) (integer) 1 2) (integer) 1事務中命令錯誤處理
# 1、命令語法錯誤，命令入隊失敗，直接自動discard退出這個事務這個在命令在執行調用之前會發生錯誤。例如，這個命令可能有語法錯誤（錯誤的參數數量，錯誤的命令名）處理方案：客戶端發生了第一個錯誤情況，在exec執行之前發生的。通過檢查隊列命令返回值:如果這個命令回答這個隊列的命令是正確的，否者redis會返回一個錯誤。如果那里發生了一個隊列命令錯誤，大部分客戶端將會退出并丟棄這個事務# 2、命令語法沒錯，但類型操作有誤，則事務執行調用之后失敗，無法進行事務回滾從我們施行了一個由于錯誤的value的key操作（例如對著String類型的value施行了List命令操作）處理方案：發生在EXEC之后的是沒有特殊方式去處理的：即使某些命令在事務中失敗，所有的其他命令都將會被執行。 127.0.0.1:6379> MULTI OK 127.0.0.1:6379> set num 10 QUEUED 127.0.0.1:6379> LPOP num QUEUED 127.0.0.1:6379> exec 1) OK 2) (error) WRONGTYPE Operation against a key holding the wrong kind of value 127.0.0.1:6379> get num "10" 127.0.0.1:6379>為什么redis不支持事務回滾
- 觀點
pipeline補充
python使用pipeline()與execute()批量進行批量操作
示例
import redis# 創建連接池并連接到redis pool = redis.ConnectionPool(host = '192.168.153.150',db=0,port=6379) r = redis.Redis(connection_pool=pool)# 第一組 pipe = r.pipeline() pipe.set('fans',50) pipe.incr('fans') pipe.incrby('fans',100) pipe.execute()# 第二組 pipe.get('fans') pipe.get('pwd') # [b'151', b'123'] result = pipe.execute() print(result)Redis常見問題匯總
Redis優點
1、讀寫速度快. 數據存放在內存中 2、支持數據類型豐富,string,hash,list,set,sorted 3、支持事務 4、可以用于緩存,消息隊列,按key設置過期時間,到期后自動刪除 5、支持數據持久化(將內存數據持久化到磁盤),支持AOF和RDB兩種持久化方式,從而進行數據恢復操作,可以有效地防止數據丟失 5、支持主從(master-slave)復制來實現數據備份,主機會自動將數據同步到從機來介紹一下redis中的數據類型
| string | 簡單key-value類型，value可為字符串和數字 | 常規計數（微博數, 粉絲數等功能） |
| hash | 是一個string類型的field和value的映射表，hash特別適合用于存儲對象 | 存儲部分可能需要變更的數據（比如用戶信息） |
| list | 有序可重復列表 | 關注列表，粉絲列表，消息隊列等 |
| set | 無序不可重復列表 | 存儲并計算關系（如微博，關注人或粉絲存放在集合，可通過交集、并集、差集等操作實現如共同關注、共同喜好等功能） |
| sorted set | 每個元素帶有分值的集合 | 各種排行榜 |
redis中的持久化方案
# RDB 快照形式，定期把內存中的數據保存到磁盤。Redis默認支持的持久化方案。速度快但是服務器斷電的時候會丟失部分數據# AOF 把所有對redis數據庫增刪改操作的命令保存到文件中。數據庫恢復時把所有的命令執行一遍即可。 # 兩種持久化方案同時開啟使用AOF文件來恢復數據庫.能保證數據的完整性,但是速度慢。使用過Redis分布式鎖么，它是什么回事？
1、從redis2.8開始，set命令集成了兩個參數，nx和ex，先拿nx來爭搶鎖，搶到之后，再用ex參數給鎖加一個過期時間防止鎖無法釋放，造成死鎖set username AAA nx ex 3 2、redis分布式鎖原理見圖緩存穿透
# 原理 緩存和數據庫都沒有的數據，而用戶反復發起請求， 如 假的用戶ID# 場景 比如發起為id為“-1”的數據或id為特別大不存在的數據。這時的用戶很可能是攻擊者，攻擊會導致數據庫壓力過大# 解決方案：1、請求校驗，接口層增加校驗，如對id做基礎校驗，id<=0的直接攔截2、都無法取到數據時也可以將key-value對寫為key-null，緩存有效時間比如30秒左右，這樣可以防止攻擊用戶反復用同一個id暴力攻擊緩存擊穿
# 原理 緩存沒有，數據庫有，一般是緩存時間到期， 順勢并發太大#解決方案 1、熱點數據不過期 2、上鎖: 重新設計緩存的使用方式，當我們通過key去查詢數據時，首先查詢緩存，如果沒有，就通過分布式鎖進行加鎖，取得鎖的進程查DB并設置緩存，然后解鎖；其他進程如果發現有鎖就等待，然后等解鎖后返回緩存數據或者再次查詢DB緩存雪崩
# 原理 緩存中大批量數據過期，導致瞬時大批量不同請求注入DB:即后端數據庫。# 解決方案 解決方案 1、緩存設置隨機時間（避免緩存設置相近的有效期；為有效期增加隨機值） 2、熱點數據不過期 1', b'123'] result = pipe.execute() print(result)Redis常見問題匯總
Redis優點
1、讀寫速度快. 數據存放在內存中 2、支持數據類型豐富,string,hash,list,set,sorted 3、支持事務 4、可以用于緩存,消息隊列,按key設置過期時間,到期后自動刪除 5、支持數據持久化(將內存數據持久化到磁盤),支持AOF和RDB兩種持久化方式,從而進行數據恢復操作,可以有效地防止數據丟失 5、支持主從(master-slave)復制來實現數據備份,主機會自動將數據同步到從機來介紹一下redis中的數據類型
| string | 簡單key-value類型，value可為字符串和數字 | 常規計數（微博數, 粉絲數等功能） |
| hash | 是一個string類型的field和value的映射表，hash特別適合用于存儲對象 | 存儲部分可能需要變更的數據（比如用戶信息） |
| list | 有序可重復列表 | 關注列表，粉絲列表，消息隊列等 |
| set | 無序不可重復列表 | 存儲并計算關系（如微博，關注人或粉絲存放在集合，可通過交集、并集、差集等操作實現如共同關注、共同喜好等功能） |
| sorted set | 每個元素帶有分值的集合 | 各種排行榜 |
redis中的持久化方案
# RDB 快照形式，定期把內存中的數據保存到磁盤。Redis默認支持的持久化方案。速度快但是服務器斷電的時候會丟失部分數據# AOF 把所有對redis數據庫增刪改操作的命令保存到文件中。數據庫恢復時把所有的命令執行一遍即可。 # 兩種持久化方案同時開啟使用AOF文件來恢復數據庫.能保證數據的完整性,但是速度慢。使用過Redis分布式鎖么，它是什么回事？
1、從redis2.8開始，set命令集成了兩個參數，nx和ex，先拿nx來爭搶鎖，搶到之后，再用ex參數給鎖加一個過期時間防止鎖無法釋放，造成死鎖set username AAA nx ex 3 2、redis分布式鎖原理見圖緩存穿透
# 原理 緩存和數據庫都沒有的數據，而用戶反復發起請求， 如 假的用戶ID# 場景 比如發起為id為“-1”的數據或id為特別大不存在的數據。這時的用戶很可能是攻擊者，攻擊會導致數據庫壓力過大# 解決方案：1、請求校驗，接口層增加校驗，如對id做基礎校驗，id<=0的直接攔截2、都無法取到數據時也可以將key-value對寫為key-null，緩存有效時間比如30秒左右，這樣可以防止攻擊用戶反復用同一個id暴力攻擊緩存擊穿
# 原理 緩存沒有，數據庫有，一般是緩存時間到期， 順勢并發太大#解決方案 1、熱點數據不過期 2、上鎖: 重新設計緩存的使用方式，當我們通過key去查詢數據時，首先查詢緩存，如果沒有，就通過分布式鎖進行加鎖，取得鎖的進程查DB并設置緩存，然后解鎖；其他進程如果發現有鎖就等待，然后等解鎖后返回緩存數據或者再次查詢DB緩存雪崩
# 原理 緩存中大批量數據過期，導致瞬時大批量不同請求注入DB:即后端數據庫。# 解決方案 解決方案 1、緩存設置隨機時間（避免緩存設置相近的有效期；為有效期增加隨機值） 2、熱點數據不過期總結
以上是生活随笔為你收集整理的Redis基于内存非关系型数据库的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 强烈推荐 10 本我私藏的数据库书单，附
- 下一篇： 干货！如何建立数据标签体系