Redis In Action 筆記（六）：使用 Redis 作為應用程式元件

tsin發表於2019-06-30

Redis筆記元件

自動補全

程式說明

實現給一個組別中的成員發郵件時，輸入字首能找出匹配的收件人；程式假設所有名字是由字母組成。

設計思路

比如，查詢abc字首的名稱：

→ 查詢範圍是(abbz, abd)
→ zrange取出該範圍
→ 但問題是這兩個元素的可能不存在
→ 向有序集合插入兩個特殊元素，一個在abbz之後，一個在abd之前
→ 根據這兩個特殊元素取排名→根據排名取範圍
→ 已知：ASCII編碼裡面，z後面的第一個字元是 '{', a前面的第一個是反引號 ' ` '
→得到 abd 之前的且所有以 abc 為字首的合法名字之後的元素「 abc{ 」 →作為查詢的結束元素
→得到 abbz 之後的第一個元素是 abb{，這個元素位置 abc 之前→用作起始元素
→特殊情況：如果是查詢的字首是aba，則起始元素是ab`
→ 由此得到查詢的範圍，即開始元素是字首的最後一個字元後退一個ASCII字元 + ' { '（如果是a則變為' ` '），結束元素是字首直接加' { '

程式碼實現

import uuid
import bisect
import redis

conn = redis.Redis(host='127.0.0.1', port=6379)

valid_characters = '`abcdefghijklmnopqrstuvwxyz{'             

# 獲得起始和結束範圍
def find_prefix_range(prefix):
    posn = bisect.bisect_left(valid_characters, prefix[-1:])  
    suffix = valid_characters[(posn or 1) - 1]                
    return prefix[:-1] + suffix + '{', prefix + '{'     

# 自動補全程式
def autocomplete_on_prefix(conn, guild, prefix):
    # 獲取起始和結束字元
    start, end = find_prefix_range(prefix)                 
    identifier = str(uuid.uuid4()) 
    # 將開始和結束加上一個唯一識別符號，避免其他使用者同時操作時相互干擾                        
    start += identifier                                    
    end += identifier
    # 要查詢的組                                      
    zset_name = 'members:' + guild

    # 向有序集合中插入起始和結束字元
    conn.zadd(zset_name, {start:0, end:0})                 
    pipeline = conn.pipeline(True)
    while 1:
        try:
            pipeline.watch(zset_name) 
            # 獲得起始和結束元素的位置
            sindex = pipeline.zrank(zset_name, start)      
            eindex = pipeline.zrank(zset_name, end) 

            # 這裡用於讓取出的元素不超過10個       
            erange = min(sindex + 9, eindex - 2)           
            pipeline.multi()

            # 移除插入的兩個元素
            pipeline.zrem(zset_name, start, end) 
            # 獲得搜尋結果          
            pipeline.zrange(zset_name, sindex, erange)     
            items = pipeline.execute()[-1]                 
            break
        except redis.exceptions.WatchError:                
            continue                                       
    # 移除可能由其他客戶端插入的用於搜尋的元素（含有{）
    return [item.decode('utf-8') for item in items if b'{' not in item]   

# 加入小組
def join_guild(conn, guild, user):
    conn.zadd('members:' + guild, {user:0})

# 退出小組
def leave_guild(conn, guild, user):
    conn.zrem('members:' + guild, user)   

# 測試執行
join_guild(conn, 'aa', 'abc')    
join_guild(conn, 'aa', 'abcd')    
join_guild(conn, 'aa', 'abcz')    
join_guild(conn, 'aa', 'abcx')    
join_guild(conn, 'aa', 'abcy')    
join_guild(conn, 'aa', 'abci')    
join_guild(conn, 'aa', 'abcj')    
join_guild(conn, 'aa', 'abd')  
items = autocomplete_on_prefix(conn, 'aa', 'abc')  
print(items)
# 輸出： ['abc', 'abcd', 'abci', 'abcj', 'abcx', 'abcy', 'abcz']

有序集合常規用途

快速判斷某個元素是否存在於集合裡面（ZSCORE key member，不存在這返回nil）
檢視某個成員在有序集合中的位置或索引（ZRANK key-name member）
取出某個範圍的元素（ZRANGE key-name start offset [WITHSCORES]）

這裡的用法

所有score設為0，當所有成員分值都相同時，按照成員的名字來進行排序；而當所有成員分值都是0的時候，成員按照字串的二進位制進行排序。

分散式鎖

實現一個分散式鎖，核心的命令是：setnx（SET if Not eXists），它的作用是當設定一個KEY時，如果該KEY不存在，才能設定成功。那麼當一個客戶端設定一個KEY成功，並將其值設定為一個唯一識別符號，其他客戶端使用同樣的命令則會設定失敗，也就是說，其他客戶端在該KEY存在的週期內，是無法成功設定該KEY的值的（程式上返回false），這相當於設定該KEY的值成功的客戶端獲得了鎖，當該客戶端使用完畢並將其刪除，其他客戶端才能夠設定該KEY。

當系統負載較大的時候，WATCH鎖導致程式進行重試的次數劇增，分散式鎖無此問題。

程式實現

 # 獲取鎖
def acquire_lock(conn, lockname, acquire_timeout=10):
    identifier = str(uuid.uuid4())                      
    end = time.time() + acquire_timeout
    # 在超時時間內不停重試，直到設定KEY的值成功，也即獲得了「鎖」
    while time.time() < end:
        if conn.setnx('lock:' + lockname, identifier):
            # 加鎖成功返回識別符號  
            return identifier
        time.sleep(.001)
    return False

# 4.4.3節中的函式改寫
def purchase_item_with_lock(conn, buyerid, itemid, sellerid):
    buyer = "users:%s" % buyerid
    seller = "users:%s" % sellerid
    item = "%s.%s" % (itemid, sellerid)
    inventory = "inventory:%s" % buyerid

    # 加鎖（這裡對整個市場加鎖）
    # 也可以改變鎖的粒度，只對操作到的商品加鎖
    locked = acquire_lock(conn, 'market:')     
    if not locked:
        return False

    pipe = conn.pipeline(True)
    try:
        pipe.zscore("market:", item)           
        pipe.hget(buyer, 'funds')              
        price, funds = pipe.execute()          
        if price is None or price > funds:     
            return None                        

        pipe.hincrby(seller, 'funds', int(price))  
        pipe.hincrby(buyer, 'funds', int(-price))  
        pipe.sadd(inventory, itemid)               
        pipe.zrem("market:", item)                 
        pipe.execute()                             
        return True
    finally:
        # 釋放鎖
        release_lock(conn, 'market:', locked) 

# 釋放鎖
def release_lock(conn, lockname, identifier):
    pipe = conn.pipeline(True)
    lockname = 'lock:' + lockname

    while True:
        try:
            pipe.watch(lockname)                
            if pipe.get(lockname) == identifier:
                pipe.multi()                    
                pipe.delete(lockname)           
                pipe.execute()                  
                return True                     

            pipe.unwatch()
            break

        except redis.exceptions.WatchError:     
            pass                                

    return False

帶超時的鎖

可以取得鎖之後，給鎖加一個超時時間，可以避免因為不可預料的情況，持有者一直持有鎖。

acquire_lock_with_timeout(conn, lockname, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())                      
    lockname = 'lock:' + lockname
    lock_timeout = int(math.ceil(lock_timeout))         

    end = time.time() + acquire_timeout
    while time.time() < end:
        if conn.setnx(lockname, identifier): 
            # 給鎖設定超時時間           
            conn.expire(lockname, lock_timeout)         
            return identifier
        # 如果鎖已存在，順便設定下超時時間
        elif conn.ttl(lockname) < 0:                    
            conn.expire(lockname, lock_timeout)         

        time.sleep(.001)

    return False

計數訊號量

計數訊號量是一種鎖，用於限制訪問同一資源的程式數
可以把上一節建立的鎖看成只能被一個程式訪問的計數訊號量
同樣有獲取鎖、釋放鎖的操作，但獲取鎖失敗時，傾向於立即返回失敗結果，而不是重試
實現超時限制特性：1.使用EXPIRE 2.使用有序集合

例子

儲存訊號量資訊的有序集合：

佔坑

def acquire_semaphore(conn, semname, limit, timeout=10):
identifier = str(uuid.uuid4())                             
now = time.time()

pipeline = conn.pipeline(True)
# 清理超時的坑位
pipeline.zremrangebyscore(semname, '-inf', now - timeout)  
pipeline.zadd(semname, {identifier::now}) # 佔個坑先                   
pipeline.zrank(semname, identifier)  # 獲取位置                      
if pipeline.execute()[-1] < limit:   # 如果坑位還足夠，就搶佔成功                     
    return identifier 

# 坑位不足，佔不到坑，就只能灰溜溜地走了
conn.zrem(semname, identifier)                             
return None

釋放坑位
```
def release_semaphore(conn, semname, identifier):
return conn.zrem(semname, identifier)  
```
公平訊號量

解決系統時間可能不一致，導致系統時間較慢的客戶端能搶先佔有訊號量的問題。
實現思路：新增一個計數器，再新增一個儲存計數訊號量資訊的有序集合（A），這個有序集合以最新的計數器的值為score，還需要另一個儲存計數訊號量的有序集(B)，score值為時間戳，用來清理超時的訊號量。B清理調超時訊號量後，與A求交集（zinterstore），B的聚合權重設為0，最終結果儲存到A，這樣一來，A通過B間接地清理掉超時訊號量。實現程式碼如下：

取得計數訊號量

def acquire_fair_semaphore(conn, semname, limit, timeout=10):
identifier = str(uuid.uuid4())                             
czset = semname + ':owner'  # 訊號量集合（B）
ctr = semname + ':counter'  # 計數器

now = time.time()
pipeline = conn.pipeline(True)
# 刪除（A）中超時的，然後與czset（B）求交集來間接刪除czset中超時的
pipeline.zremrangebyscore(semname, '-inf', now - timeout) 
# 求交集，semname聚合權重為0，這樣不影響（A）的score值 
pipeline.zinterstore(czset, {czset: 1, semname: 0})        

pipeline.incr(ctr)                                         
counter = pipeline.execute()[-1]                           

pipeline.zadd(semname, identifier, now) # 以時間戳為score的zset                   
pipeline.zadd(czset, identifier, counter)  # 以計數為score的zset                 

pipeline.zrank(czset, identifier)  # 獲取位置                        
if pipeline.execute()[-1] < limit:                         
    return identifier                                      

pipeline.zrem(semname, identifier)                         
pipeline.zrem(czset, identifier)                           
pipeline.execute()
return None

釋放鎖

比非公平訊號量多了一個集合要刪除。

def release_fair_semaphore(conn, semname, identifier):
pipeline = conn.pipeline(True)
pipeline.zrem(semname, identifier)
pipeline.zrem(semname + ':owner', identifier)
return pipeline.execute()[0]

重新整理訊號量

前面設定的計數訊號量10s就超時，需要進行重新整理，防止過期

# 重新整理訊號量            
def refresh_fair_semaphore(conn, semname, identifier):
# zadd操作，元素不存在時執行新增操作，返回1；存在時則更新元素，返回0
if conn.zadd(semname, identifier, time.time()): 
    # 如果是新增，將判斷語句新增的刪除，返回False，表示已過期           
    release_fair_semaphore(conn, semname, identifier)      
    return False 

# 如果是更新，直接跳到這裡，返回True，表示重新整理成功                                         
return True

獲取訊號量之加鎖版

用於消除競爭條件

def acquire_semaphore_with_lock(conn, semname, limit, timeout=10):
# 設定一個超短時間過期的鎖
identifier = acquire_lock(conn, semname, acquire_timeout=.01)
# 如果設定成功
if identifier:
    try:
        # 獲取公平訊號量
        return acquire_fair_semaphore(conn, semname, limit, timeout)
    finally:
        # 將獲得的鎖刪除
        release_lock(conn, semname, identifier)

計數訊號量總結
- 如果對系統的時鐘差異可以接受，可以使用第一種
- 不能接受系統的時鐘差異，可以使用公平訊號量
- 希望訊號量一直執行正確，使用第三種，加鎖獲取訊號量（推薦）

任務佇列

import redis

conn = redis.Redis(host='127.0.0.1', port=6379)

# 已售出商品郵件佇列
def send_sold_email_via_queue(conn, seller, item, price, buyer):
    data = {
        'seller_id': seller,                    
        'item_id': item,                        
        'price': price,                         
        'buyer_id': buyer,                      
        'time': time.time()                     
    }
    conn.rpush('queue:email', json.dumps(data)) 

# 讀取列表中的發郵件任務，傳送郵件
def process_sold_email_queue(conn):
    while not QUIT:
        packed = conn.blpop(['queue:email'], 30)                  
        if not packed:                                            
            continue                                              

        to_send = json.loads(packed[1])                           
        try:
            fetch_data_and_send_sold_email(to_send)               
        except EmailSendError as err:
            log_error("Failed to send sold email", err, to_send)
        else:
            log_success("Sent sold email", to_send)

# 可以執行多種任務的佇列
def worker_watch_queue(conn, queue, callbacks):
    while not QUIT:
        packed = conn.blpop([queue], 30)                    
        if not packed:                                      
            continue                                        

        name, args = json.loads(packed[1]) 
        # 如果任務沒有在callbacks中註冊                 
        if name not in callbacks:                           
            log_error("Unknown callback %s"%name)           
            continue 
        # 呼叫在callbacks中已註冊的函式                                       
        callbacks[name](*args)   

# 任務優先順序 
# 實現原理：blpop可傳入多個list，排在前面的list優先處理
def worker_watch_queues(conn, queues, callbacks):   
    while not QUIT:
        packed = conn.blpop(queues, 30)  # queues是由多個list組成的list           
        if not packed:
            continue

        name, args = json.loads(packed[1])
        if name not in callbacks:
            log_error("Unknown callback %s"%name)
            continue
        callbacks[name](*args)   

# 延遲任務
# 實現思路：把所有要延遲的任務加到有序集合，執行時間作為score
# 另外的一個程式用來查詢有序集合裡面是否有要立即執行的任務
# 如果有的話，就從有序集合移除，新增到佇列中
def execute_later(conn, queue, name, args, delay=0):
    identifier = str(uuid.uuid4())                          
    item = json.dumps([identifier, queue, name, args])      
    if delay > 0: # 新增到有序集合 延遲任務執行
        conn.zadd('delayed:', item, time.time() + delay)    
    else: # 立即執行的任務
        conn.rpush('queue:' + queue, item)                  
    return identifier    

# 執行延遲任務
def poll_queue(conn):
    while not QUIT:
        # 取出第一個元素
        item = conn.zrange('delayed:', 0, 0, withscores=True) 
        # 如果沒有元素 休眠0.01s  
        if not item or item[0][1] > time.time():                
            time.sleep(.01)                                     
            continue                                            

        # 取出要執行的任務
        item = item[0][0]                                       
        identifier, queue, function, args = json.loads(item)    

        locked = acquire_lock(conn, identifier)                 
        if not locked:                                          
            continue                                            
        # 從有序集合移除該任務 並 新增到任務佇列
        if conn.zrem('delayed:', item):                         
            conn.rpush('queue:' + queue, item)                  

        release_lock(conn, identifier, locked)

參考資料：https://redislabs.com/ebook/part-2-core-co...

Was mich nicht umbringt, macht mich stärker

Redis In Action 筆記（五）：使用 Redis 支援應用程式
2019-06-29
Redis筆記
Redis In Action 筆記（七）降低記憶體使用
2019-07-06
Redis筆記記憶體
Redis In Action 筆記（二）：文章投票（PHP 版）
2019-06-08
Redis筆記PHP
如何基於 Redis 構建應用程式元件
2018-04-12
Redis元件
配置Redis作為快取（六種淘汰策略）
2018-03-18
Redis快取
Redis In Action 筆記（一）：基本資料型別及其操作
2019-06-07
Redis筆記資料型別
Redis In Action 筆記（四）：資料安全和效能優化
2019-06-23
Redis筆記優化
Redis 學習筆記（六）Redis 如何實現訊息佇列
2022-02-12
Redis筆記佇列
Redis筆記
2019-03-24
Redis筆記
Redis In Action 筆記（三）：使用者登入、瀏覽記錄的快取與管理
2019-06-12
Redis筆記快取
Redis學習筆記--Redis持久化
2017-03-30
Redis筆記持久化
redis筆記1.0
2021-01-09
Redis筆記
redis配置筆記
2018-01-10
Redis筆記
redis應用
2018-08-22
Redis
Redis學習筆記六：持久化實驗(AOF,RDB)
2021-05-21
Redis筆記持久化
Redis學習筆記【01】 - 安裝Redis
2021-09-09
Redis筆記
Redis學習筆記（一）——初識Redis
2018-08-18
Redis筆記
Redis筆記01-Redis配置檔案
2019-01-19
Redis筆記
redis學習筆記(三)–Redis的功能
2018-10-02
Redis筆記
（Redis學習筆記）：Redis解決方案
2020-11-29
Redis筆記
《Redis實戰》筆記-Redis的有序集合
2018-03-20
Redis筆記
redis與叢集實用操作筆記
2022-01-27
Redis筆記
Redis 複習筆記
2020-05-26
Redis筆記
redis學習筆記
2021-05-05
Redis筆記
筆記：後端 - Redis
2018-09-17
筆記後端Redis
Redis筆記（10）：事件
2020-11-15
Redis筆記事件
redis筆記補充
2022-04-05
Redis筆記
Redis入門筆記
2018-07-05
Redis筆記
Redis 學習筆記
2010-12-10
Redis筆記
Redis作者談Redis應用場景
2017-10-09
Redis
Redis 應用-Geo
2019-07-05
Redis
Redis 應用-限流
2019-07-05
Redis
「進擊Redis」六、Redis List運用場景、API解析
2020-12-08
RedisAPI
在應用程式中將OJB作為一個儲存層使用（六） (轉)
2007-08-17
Redis 學習筆記（篇七）：Redis 持久化
2019-08-02
Redis筆記持久化
Redis學習筆記（三）redis 的鍵管理
2022-02-06
Redis筆記
Redis作為LRUCache的實現
2016-11-09
Redis
redis 作為快取總結
2017-01-16
Redis快取