python3 redis长链接超时_python3之redis

1、redis简介

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

1. 使用Redis有哪些好处？

(1) 速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)

(2) 支持丰富数据类型，支持string，list，set，sorted set，hash

(3) 支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行

(4) 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除

2. redis相比memcached有哪些优势？

(1) memcached所有的值均是简单的字符串，redis作为其替代者，支持更为丰富的数据类型

(2) redis的速度比memcached快很多

(3) redis可以持久化其数据

3. redis常见性能问题和解决方案：

(1) Master最好不要做任何持久化工作，如RDB内存快照和AOF日志文件

(2) 如果数据比较重要，某个Slave开启AOF备份数据，策略设置为每秒同步一次

(3) 为了主从复制的速度和连接的稳定性，Master和Slave最好在同一个局域网内

(4) 尽量避免在压力很大的主库上增加从库

(5) 主从复制不要用图状结构，用单向链表结构更为稳定，即：Master

这样的结构方便解决单点故障问题，实现Slave对Master的替换。如果Master挂了，可以立刻启用Slave1做Master，其他不变。

4. MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据

相关知识：redis 内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。redis 提供 6种数据淘汰策略：

voltile-lru：从已设置过期时间的数据集(server.db[i].expires)中挑选最近最少使用的数据淘汰

volatile-ttl：从已设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰

volatile-random：从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰

allkeys-lru：从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰

allkeys-random：从数据集(server.db[i].dict)中任意选择数据淘汰

no-enviction(驱逐)：禁止驱逐数据

5. Memcache与Redis的区别都有哪些？

1)、存储方式

Memecache把数据全部存在内存之中，断电后会挂掉，数据不能超过内存大小。

Redis有部份存在硬盘上，这样能保证数据的持久性。

2)、数据支持类型

Memcache对数据类型支持相对简单。

Redis有复杂的数据类型。

3)，value大小

redis最大可以达到1GB，而memcache只有1MB

6. Redis 常见的性能问题都有哪些？如何解决？

1).Master写内存快照，save命令调度rdbSave函数，会阻塞主线程的工作，当快照比较大时对性能影响是非常大的，会间断性暂停服务，所以Master最好不要写内存快照。

2).Master AOF持久化，如果不重写AOF文件，这个持久化方式对性能的影响是最小的，但是AOF文件会不断增大，AOF文件过大会影响Master重启的恢复速度。Master最好不要做任何持久化工作，包括内存快照和AOF日志文件，特别是不要启用内存快照做持久化,如果数据比较关键，某个Slave开启AOF备份数据，策略为每秒同步一次。

3).Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源，导致服务load过高，出现短暂服务暂停现象。

4). Redis主从复制的性能问题，为了主从复制的速度和连接的稳定性，Slave和Master最好在同一个局域网内

7, redis 最适合的场景

Redis最适合所有数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能，跟传统意义上的持久化有比较大的差别，那么可能大家就会有疑问，似乎Redis更像一个加强版的Memcached，那么何时使用Memcached,何时使用Redis呢?

如果简单地比较Redis与Memcached的区别，大多数都会得到以下观点：

1 、Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

2 、Redis支持数据的备份，即master-slave模式的数据备份。

3 、Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。

(1)、会话缓存(Session Cache)

最常用的一种使用Redis的情景是会话缓存(session cache)。用Redis缓存会话比其他存储(如Memcached)的优势在于：Redis提供持久化。当维护一个不是严格要求一致性的缓存时，如果用户的购物车信息全部丢失，大部分人都会不高兴的，现在，他们还会这样吗？

幸运的是，随着 Redis 这些年的改进，很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。

(2)、全页缓存(FPC)

除基本的会话token之外，Redis还提供很简便的FPC平台。回到一致性问题，即使重启了Redis实例，因为有磁盘的持久化，用户也不会看到页面加载速度的下降，这是一个极大改进，类似PHP本地FPC。

再次以Magento为例，Magento提供一个插件来使用Redis作为全页缓存后端。

此外，对WordPress的用户来说，Pantheon有一个非常好的插件 wp-redis，这个插件能帮助你以最快速度加载你曾浏览过的页面。

(3)、队列

Reids在内存存储引擎领域的一大优点是提供 list 和 set 操作，这使得Redis能作为一个很好的消息队列平台来使用。Redis作为队列使用的操作，就类似于本地程序语言(如Python)对 list 的 push/pop 操作。

如果你快速的在Google中搜索“Redis queues”，你马上就能找到大量的开源项目，这些项目的目的就是利用Redis创建非常好的后端工具，以满足各种队列需求。例如，Celery有一个后台就是使用Redis作为broker，你可以从这里去查看。

(4)，排行榜/计数器

Redis在内存中对数字进行递增或递减的操作实现的非常好。集合(Set)和有序集合(Sorted Set)也使得我们在执行这些操作的时候变的非常简单，Redis只是正好提供了这两种数据结构。所以，我们要从排序集合中获取到排名最靠前的10个用户–我们称之为“user_scores”，我们只需要像下面一样执行即可：

当然，这是假定你是根据你用户的分数做递增的排序。如果你想返回用户及用户的分数，你需要这样执行：

ZRANGE user_scores 0 10 WITHSCORES

Agora Games就是一个很好的例子，用Ruby实现的，它的排行榜就是使用Redis来存储数据的，你可以在这里看到。

(5)、发布/订阅

最后(但肯定不是最不重要的)是Redis的发布/订阅功能。发布/订阅的使用场景确实非常多。我已看见人们在社交网络连接中使用，还可作为基于发布/订阅的脚本触发器，甚至用Redis的发布/订阅功能来建立聊天系统！(不，这是真的，你可以去核实)。

Redis提供的所有特性中，我感觉这个是喜欢的人最少的一个，虽然它为用户提供如果此多功能。

2、python链接redis操作

redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

importredis#创建redis链接对象

r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)#存储键值对

r.set('site','www.qi.cn')#获取值

print(r.get('site'))#指定decode_responses为True，表示输出为字符串

red = redis.StrictRedis(host='127.0.0.1',port=6379,decode_responses=True)#默认redis入库编码是utf-8，如果要修改的话，需要指明 charset 和 decode_responsers 为True#test = redis.StrictRedis(host='localhost', port=6379, db=0, password=None, socket_timeout=None, connection_pool=None, charset='utf-8', errors='strict', decode_responses=False, unix_socket_path=None)

red.lpush('list1','mongdb','redis','mysql')print(r.lrange('list1',0,-1))print(r.llen('list1'))#output:

www.qi.cn

['mysql', 'redis', 'mongdb']3

连接池：

redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

importredis#创建连接池

pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)#创建链接对象

r=redis.Redis(connection_pool=pool)#设置集合

r.sadd('set1','v1','v2','v3')

r.sadd('set1','v2')#显示集合的值

print(r.smembers('set1'))#使用strictRedis连接池

rs = redis.StrictRedis(connection_pool=pool)

r.lpush('l1','python','memcache','redis','mongodb')print(r.lrange('l1',0,-1))#output:

{'v3', 'v1', 'v2'}

['mongodb', 'redis', 'memcache', 'python']

(1)数据string操作

redis中的String在在内存中按照一个name对应一个value来存储的。

set key value [EX seconds] [PX milliseconds] [NX|XX]

参数：

ex，过期时间(秒)

importredis#创建连接池

pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)#创建链接对象

r=redis.Redis(connection_pool=pool)

r.set('test','dddddddddddd',ex=3,nx=True)print(r.get('test'))

setnx(name,value)：设置值，只有在name不存在是才执行操作

setex(name,value,time)：设置值过期时间，单位为秒

psetex(name,time_ms,value)：设置值，过期时间为毫秒

mset(*args,**kwargs)：批量设置多个值

get(name)：获取值

getrange(key,start,end)：获取子序列,根据字节获取

setrange(name,oofset,value)：修改字符串内容，从指定字符串索引开始向后替换

importredis#创建连接池

pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)#创建链接对象

r=redis.Redis(connection_pool=pool)

r.set('test','12345',nx=True)

r.setrange('test',0,'8888')print(r.get('test'))

setbit(name,offset,value)：对name对应值的二进制表示的位进行操作

getbit(name,offset)：获取name对应的二进制位表示的值，只能是0或1

importredis

r=redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.set('name','p')print(r.get('name'))#打印p,q对应的ascii码

print(ord('p'),ord('q'))#打印ascii码对应的二进制

print(bin(ord('p')),bin(ord('q')))print('修改前7位的值：',r.getbit('name','7'))#设置二进制位的第7位为1，相当于移动ascii码位112为113对应的字符为q

r.setbit('name','7','1')print('修改后7位的值：',r.getbit('name','7'))print(r.get('name'))#output：

p112 1130b1110000 0b1110001

修改前7位的值： 0

修改后7位的值：1q

strlen(name)：返回name对应值的字节长度，一个汉字3个字节

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.set('name','python')print(r.strlen('name')) #输出6个字节

incr(self,name,amount=1)：自增name对应的值，当name不存在时，则创建name=amount，否则自增

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)#r.set('name','python')

r.set('age','1')print(r.incr('age','3')) #结果为4

decr(self,name,amount=1)：自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.set('age','10')print(r.decr('age','3')) #输出为7

append(key,value)：在name对应的值后面追加内容

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.set('age','10')print(r.get('age'))print(r.append('age','11'))print(r.get('age'))#output：

10

4

1011

(2)hash操作

hset(name,key,value)：在name对应的hash中设置一个键值对，不存在则创建否则修改

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hset('haset','python','3.5')print(r.hget('haset','python'))

r.hset('haset','redis','1.8')print(r.hgetall('haset'))#output：

3.5{'python': '3.5', 'redis': '1.8'}

hmset(name,mapping)：在name对应的hash中批量设置键值对

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})print(r.hmget('hashmore','k1','k2','k3'))print(r.hgetall('hashmore'))

hget(name,key)：获取hash中的value

hmget(name,keys,*args)：获取过个hash的key的值

hgetall(name)：获取hash的所有键值对

hlen(name)：获取hash中键值对的个数

hkeys(name)：获取hash中所有keys的值

hvals(name):获取hash中所有value的值

hexists(name,key)：检查hash中是否存在key

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})print(r.hmget('hashmore','k1','k2','k3'))print(r.hgetall('hashmore'))print(r.hexists('hashmore','k2'))print(r.hexists('hashmore','k4'))#output：

['v1', 'v2', 'v3']

{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

True

False

hdel(name,*key)：删除hash中的key

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})print(r.hgetall('hashmore'))print(r.hdel('hashmore','k3'))print(r.hgetall('hashmore'))#output：

{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}1{'k2': 'v2', 'k1': 'v1'}

hincrby(name,key,amount=1)：自增hash中指定的key的值，不存在则创建key=amount

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3'})print(r.hgetall('hashmore'))

r.hincrby('hashmore','k1','2')print(r.hgetall('hashmore'))

hincrbyfloat(name,key,amount=1.0)：自增hash中指定的key的值，同上针对浮点数

hscan(name,cursor=0,match=None,count=None)：增量迭代获取hash中数据，cursor游标，match匹配key默认所有，count获取的个数。

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4'})print(r.hgetall('hashmore'))print(r.hscan('hashmore',cursor=2,match='k2',count=1))print(r.hscan('hashmore',count=4))

#output：

{'k1': '1', 'k3': '3', 'k2': '2', 'k4': '4'}

(0, {'k2': '2'})

(0, {'k1': '1', 'k3': '3', 'k2': '2', 'k4': '4'})

hscan_iter(name,match=None,count=None)：利用yield封装hscan创建生成器，实现分批获取数据

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4','k5':'5','k6':'6','k7':'7','k8':'8'})

oo= r.hscan_iter('hashmore')print(next(oo))print(next(oo))print(next(oo))print(next(oo))#output:

('k2', '2')

('k7', '7')

('k8', '8')

('k5', '5')

(3)list操作

lpush(name,values)：在列表中添加元素，每个新元素都从左边开始添加

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.lpush('l3',1,2)print(r.lrange('l3',0,-1))

r.lpush('l3','88')print(r.lrange('l3',0,-1))#output：

['2', '1']

['88', '2', '1']

lpushx(name,value)：在列表中添加元素，只有在name存在时才添加

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.lpushx('l4',1)print(r.lrange('l4',0,-1))

r.lpush('l4',2)

r.lpushx('l4',1)print(r.lrange('l4',0,-1))#output:

[]

['1', '2']

llen(name)：name对应的list元素的长度

linsert(name,where,refvalue,value)：在name对应的列表的某个值前或后插入一个新值，where指定前或后(befor/after)，refvalue参考值即指定的元素，value要插入的值

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.lpush('num','1','2')

r.linsert('num','after','2','python')#在2后面添加python元素值

r.linsert('num','before','1','redis') #在1之前插入redis

print(r.lrange('num',0,-1))#output:

['2', 'python', 'redis', '1']

lset(name,index,value)：对列表中的某个索引位的值修改

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)print(r.lrange('num',0,-1))

r.lset('num','0','hello')print(r.lrange('num',0,-1))#output：

['2', 'python', 'redis', '1']

['hello', 'python', 'redis', '1']

lrem(name,value,num)：在name对应的list中删除指定的值

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)print(r.lrange('num',0,-1))

r.lrem('num','1','2') #2为num指定的值的个数,可以指定-2从后往前删除

print(r.lrange('num',0,-1))#output:

['1', 'hello', 'python', 'redis', '1']

['hello', 'python', 'redis']

lpop(name)：在name对应的列表的左侧获取第一个元素并删除，并返回参数的元素

lindex(name,index)：在name对应的列表中根据索引获取列表元素

ltrim(name,start,end)：在name对应的列表中移除start到end之间的值

lrange(name,start,end)：列表分片获取数据

rpoplush(src,dst):获取源列表最后一个元素的值，并将它添加到目标列表中的最左边

blpop(keys,timeout)：将多个列表排列，按照从左到右去pop对应列表的元素

brpoplpush(src,dst,timeout=0)：从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

(4)set操作

sadd(name,values)：添加元素到集合

scard(name)：获取集合中元素的个数

sdiff(keys,*args)：在第一个集合中的元素且不在其他集合的元素的集合

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.sadd('s1',1,2,3)

r.sadd('s2',4,5,2)

r.sadd('s3',7,8,1)print(r.sdiff('s1','s2','s3'))#output:

{'3'}

sdiffstore(dest,keys,*args)：在第一个keys中的集合元素且不在其他集合中的元素添加到dest新集合中

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)#r.sadd('s1',1,2,3)#r.sadd('s2',4,5,2)#r.sadd('s3',7,8,1)

print(r.sdiffstore('s4','s1','s2','s3'))print(r.smembers('s4'))

sinter(keys,*args)：获取多个集合的并集

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.sadd('s1',1,2,3)

r.sadd('s2',4,5,2)print(r.sinter('s1','s2'))#output：

{'2'}

sinterstore(dest,keys,*args)：获取多个集合的并集并将结果加入到dest集合中

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.sadd('sex1',1,2,3,4)

r.sadd('sex2',4,5,2,7)

r.sadd('sex3',7,8,1,4,2)

r.sinterstore('sex4','sex1','sex2','sex3')print(r.smembers('sex4'))#output：

{'4', '2'}

sismember(name,value)：检查value是否在集合中

importredis

r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.sadd('sex3',7,8,1,4,2)print(r.sismember('sex3','8'))#output：

True

smembers(name)：获取集合的所有成员

smove(src,dst,value)：将源集合中的某个成员移动到目标集合中

spop(name)：从集合的右侧(尾部)移除一个成员，并将其返回

srandmember(name,numbers)：从name对应的集合中随机获取 numbers 个元素

srem(name,values)：在name对应的集合中删除某些值

sunion(keys,*args)：并集显示多个集合元素

sunionstore(dest,keys,*args)：获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

sscan(name,cursor=0,match=None,count=None)：同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

sscan_iter(name,match=None,count=None)：同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

(5)有序集合操作

在集合的基础上，为每个元素排序，元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

zadd(name,*args,**kwargs)：在name对应的有序集合中添加元素

zcard(name)：获取name对应的有序集合元素的数量

zcount(name,min,max)：获取name对应的有序集合中分数 在 [min,max] 之间的个数

zincrby(name,value,amount)：自增name对应的有序集合的 name 对应的分数

r.zrange(name, start, end, desc=False, withscores=Flase, score_cast_func=float)：按照索引范围获取name对应的有序集合的元素

zrank(name, value)：获取某个值在 name对应的有序集合中的排行(从 0 开始)

zrangebylex(name, min, max, start=None, num=None)：当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值

zrem(name, values)：删除name对应的有序集合中值是values的成员

zremrangebyrank(name, min, max)： 根据排行范围删除

zremrangebyscore(name, min, max)：根据分数范围删除

zremrangebylex(name, min, max)：根据值返回删除

zscore(name, values)：获取name对应有序集合中 value 对应的分数

zinterstore(dest, keys, aggregate=None)：获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作

zunionstore(dest, keys, aggregate=None)：获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)：同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

zscan_iter(name, match=None, count=None,score_cast_func=float)：同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

(6)其他操作

delete(*name)：根据删除redis中的任意数据类型

exists(name)：检测redis的name是否存在

keys(pattern='*')：根据模型获取redis的name

expire(name,time)：为某个redis的某个name设置超时时间

rename(src, dst)：对redis的name重命名为

move(name,db)：将redis的某个值移动到指定的db下

randomkey()：随机获取一个redis的name(不删除)

type(name)：获取name对应值的类型

scan(cursor=0,match=None,count=None)：同字符串操作，用于增量迭代获取key

scan_iter(match=None,count=None)：同字符串操作，用于增量迭代获取key

3、python对redis管道操作

redis默认在执行每次请求都会创建(连接池申请链接)和断开(归还连接池)一次连接操作，如果想要再一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline是原子性操作。

importredis

pool= redis.ConnectionPool(host='0.0.0.0', port=6379)

r= redis.Redis(connection_pool=pool)#pipe = r.pipeline(transaction=False)

pipe = r.pipeline(transaction=True)

r.set('name', 'python')

r.set('age', '18')

pipe.execute()

4、python对redis发布与订阅

demo:

#!/usr/bin/env python#-*- coding:utf-8 -*-

importredisclassRedisHelper:'''类'''

def __init__(self):#链接

self.__conn = redis.Redis(host='0.0.0.0')

self.chan_sub= 'fm104.5'

#创建频道

self.chan_pub = 'fm104.5'

defpublic(self,info):'''公共的'''self.__conn.publish(self.chan_pub,info)'''将内容发布到频道'''

returnTruedefsubscribe(self):

pub= self.__conn.pubsub()

pub.subscribe(self.chan_sub)

pub.parse_response()return pub

发布者：

#!/usr/bin/env python#-*- coding:utf-8 -*-#导入模块

from redis_demo.demo importRedisHelper#实例化

obj =RedisHelper()#把内容发布到频道

obj.public('python')

订阅者：

#!/usr/bin/env python#-*- coding:utf-8 -*-

from redis_demo.demo importRedisHelper

obj=RedisHelper()

redis_sub=obj.subscribe()whileTrue:

msg=redis_sub.parse_response()print(msg)print(type(msg))

运行方式：

先启动demo, 启动订阅者，启动发布者，订阅者接受消息。

---------------------------------------------------------------------------------------------