Redis

列表

lpush左插入、rpush右插入、lrange查询集合

127.0.0.1:6379> lpush list v1
(integer) 1
127.0.0.1:6379> lpush list v2
(integer) 2
127.0.0.1:6379> lpush list v3
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> LRANGE list 0 1
1) "v3"
2) "v2"
127.0.0.1:6379> LRANGE list 0 0
1) "v3"
127.0.0.1:6379> rpush list rv0
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "v3"
2) "v2"
3) "v1"
4) "rv0"

lpop左移除、rpop右移除

127.0.0.1:6379> lrange list 0 -1
1) "v3"
2) "v2"
3) "v1"
4) "rv0"
127.0.0.1:6379> lpop list
"v3"
127.0.0.1:6379> lrange list 0 -1
1) "v2"
2) "v1"
3) "rv0"
127.0.0.1:6379> rpop list
"rv0"
127.0.0.1:6379> lrange list 0 -1
1) "v2"
2) "v1"

lindex下标查询、llen长度查询

127.0.0.1:6379> lrange list 0 -1
1) "v4"
2) "v3"
3) "v2"
4) "v1"
127.0.0.1:6379> lindex list 1
"v3"
127.0.0.1:6379> lindex list 0
"v4"
127.0.0.1:6379> llen list
(integer) 4

blpop、brpop

BRPOP 是 Redis 的一个阻塞式列表弹出命令，用于从指定的一个或多个列表中弹出最后一个元素。它和BLPOP 不同之处在于它是从列表的尾部弹出元素，而不是从头部。
这种阻塞式弹出操作通常用于实现消息队列。如果列表为空，就会阻塞等待直到有消息可供处理。timeout: 阻塞超时时间，如果所有指定的列表都为空，命令将阻塞直到有元素可弹出或超时。

# 连接到本地 Redis 服务器
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)
a = ['item1','item2','item3','item4','item5','item6']
# 将元素推入列表
r.rpush('my_queue',*a)
# 使用 blpop 弹出元素
result = r.blpop('my_queue', timeout=5)  # 设置超时时间为 5 秒

['item1', 'item2', 'item3', 'item4', 'item5', 'item6']
['item2', 'item3', 'item4', 'item5', 'item6']

字符串

set、incr递增、decr递减

• 虽然输入是int类型，但是set会自动转换为string

r.set('my_queue', 5)# 对 key 为 'my_queue' 的值执行递减操作
value = r.decr('my_queue')
# 获取递减后的值
print(f'New value: {value}')new_value = r.incr('my_queue')print(f'New value: {new_value}')

New value: 4
New value: 5

可以看到就算是赋值也已经改变了my_queue键的值。

keys取键、get取值、delete

# 将元素推入列表
r.setnx('my_queue:ddd:count',123)
r.setnx('my_queue:aaa:count',456)
r.setnx('my_queue',789)
r.setnx('my_queue',101)
r.set('my_queue:kkk:count',159)print(r.keys('*'))
keys = r.keys('my_queue:*:count')
# 打印匹配的键列表
print(keys)
value = r.get(keys[0])
print(value)
r.delete('my_queue:ddd:count')
print(r.keys('*'))

['my_queue:kkk:count', 'my_queue', 'my_queue:aaa:count', 'my_queue:ddd:count']
['my_queue:kkk:count', 'my_queue:aaa:count', 'my_queue:ddd:count']
159
['my_queue:kkk:count', 'my_queue', 'my_queue:aaa:count']

关于为什么delete了还能取到值(

delete只是删除了redis队列的键值对，keys是已经赋过值了所以不受影响。

r.setnx(f'rtp_task:{1}:{123}:count',123)
r.setnx(f'rtp_task:{2}:{456}:count',456)
r.setnx(f'rtp_task:{3}:{789}:count',789)
r.setnx(f'rtp_task:{4}:{101}:count',101)
r.setnx(f'rtp_task:{5}:{159}:count',159)keys = r.keys('rtp_task:*:count')
r.delete('rtp_task:1:123:count')
print(r.keys("*"))
print(keys)

['rtp_task:4:101:count', 'rtp_task:2:456:count', 'rtp_task:3:789:count', 'rtp_task:5:159:count']
['rtp_task:4:101:count', 'rtp_task:2:456:count', 'rtp_task:3:789:count', 'rtp_task:1:123:count', 'rtp_task:5:159:count']

setnx

含义（setnx = SET if Not eXists）：如果不存在，则set。

r.setnx('my_queue:ddd:count',123)
print(r.get('my_queue:ddd:count'))
123

r.setnx('my_queue:ddd:count',123)
r.setnx('my_queue:ddd:count',456)
print(r.get('my_queue:ddd:count'))
123

threading

Thread

创建线程

在创建线程时，传递参数需要是一个可迭代的对象，如果只有一个参数，需要在参数后面添加逗号，以表示它是一个元组而不是一个单一的值。

如果写成 args=(a,)，它会被解释为一个包含单一元素的元组，而如果你写成 args=(a)，它会被解释为 args=a，这样就不再是一个元组。

a = "this is message"def iptest(message):print(message)t = threading.Thread(target=iptest, args=(a,))

start、join

a = "this is message"def iptest(message):print(message)t = threading.Thread(target=iptest, args=(a,))t.start()

this is message

join方法的作用是确保thread子线程执行完毕后才能执行下一个线程。

没加join前：

def iptest():print("message1\n")for i in range(10):# time.sleep() 函数推迟调用线程的运行，可通过参数secs指秒数，表示进程挂起的时间。time.sleep(0.1)print('message2')
def main():add_thread = threading.Thread(target=iptest, name="T2")add_thread.start()print("done")if __name__ == '__main__':main()

message1
donemessage2

加join后

message1message2
done

消息队列

import redis
import threading
import time
import json# 连接到本地 Redis 服务器
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)def producer(queue_name):# 生产者线程，模拟向队列中推送任务for i in range(5):message = {'task_id': i, 'data': f'Task {i}'}r.rpush(queue_name, json.dumps(message))time.sleep(1)def consumer(queue_name, worker_id):while True:# 消费者线程，使用 blpop 从队列中阻塞获取任务message = r.blpop(queue_name, timeout=10)if message:task = json.loads(message[1])print(f"Worker {worker_id} processing task: {task} \n")# 模拟任务处理时间time.sleep(2)# 模拟任务处理完成后，更新任务计数r.decr(f'rtp_task:{task["task_id"]}:count')num_task = r.get(f'rtp_task:{task["task_id"]}:count')print(f'taskid{task["task_id"]},num_task{num_task}')if __name__ == '__main__':# 设置初始任务计数for i in range(5):r.setnx(f'rtp_task:{i}:count', 3)# 创建一个生产者线程producer_thread = threading.Thread(target=producer, args=('product',))producer_thread.start()# 创建多个消费者线程num_consumers = 3consumer_threads = []for i in range(num_consumers):consumer_thread = threading.Thread(target=consumer, args=('product', i + 1))consumer_threads.append(consumer_thread)consumer_thread.start()# 等待生产者线程和消费者线程完成producer_thread.join()for consumer_thread in consumer_threads:consumer_thread.join()

Worker 2 processing task: {'task_id': 0, 'data': 'Task 0'} Worker 1 processing task: {'task_id': 1, 'data': 'Task 1'} Worker 3 processing task: {'task_id': 2, 'data': 'Task 2'} taskid0,num_task2
taskid1,num_task2
Worker 2 processing task: {'task_id': 3, 'data': 'Task 3'} taskid2,num_task2
Worker 1 processing task: {'task_id': 4, 'data': 'Task 4'} taskid3,num_task2
taskid4,num_task2