def list_item(conn,userid,goodsname,price):
    #使用有序集合（market:）来管理投放到市场中的商品
    #商品的key为userid:goodsid
    inventory = 'inventory:%s' %(userid)
    user = 'User:%s' %(userid)
    goodsitem = '%s:%s' %(userid,goodsname)
    end = time.time() + 5
    pipe = conn.pipeline()
    while time.time() < end:
        try:
            pipe.watch(inventory) #监视包裹发生的变化
            if not pipe.sismember(inventory,goodsname):  #检查用户是否仍然持有将要被放入市场的商品
                pipe.unwatch()
                return None
            pipe.multi()
            pipe.zadd('market:',{goodsitem:price}) #将商品投放到市场
            pipe.srem(inventory, goodsname) #从用户包裹中删除该商品
            pipe.execute()
            print('商场中的商品：',conn.zrange('market:', 0, -1,withscores=True))
            print('商品投放市场后用户{}的商品：{}'.format(userid, conn.smembers(inventory)))
            return True
        except redis.exceptions.WatchError as e:
            print(e)
    return False

def purchase_item(conn, buyerid, goodsname, sellerid):
    buyer = 'User:{}'.format(buyerid) #买家key
    seller = 'User:{}'.format(sellerid) #卖家key
    buy_inventory = 'inventory:{}'.format(buyerid)   #买家包裹key
    sell_inverntory = 'inventory:{}'.format(sellerid)   #卖家包裹key
    goodsitem = '{}:{}'.format(sellerid,goodsname)  #市场中的商品key
    
    end = time.time() + 5
    pipe = conn.pipeline()
    while time.time() < end:
        try:
            pipe.watch('market:',buyer)  #对商品买卖市场以及买家的个人信息进行监视
            funds = int(pipe.hget(buyer,'funds'))  #得到买家拥有的钱
            print('买家手上的钱：', funds)
            price = pipe.zscore('market:', goodsitem)  #得到商品的价格
            print('price:',price)  
            if funds < price:
                pipe.unwatch()
                return None
            
            pipe.multi()
            pipe.hincrby(buyer, 'funds', int(-price))  #买家的钱减少
            pipe.hincrby(seller, 'funds', int(price))  #卖家的钱增加
            pipe.sadd(buy_inventory,goodsname)
            pipe.zrem('market:', goodsitem)
            pipe.execute()
            print('交易市场中的商品：', conn.zrange('market:', 0, -1, withscores=True))
            print('买家现在手中的钱：',conn.hget(buyer, 'funds'))
            print('买家包裹内容：', conn.smembers(buy_inventory))
            print('卖家现在手中的钱：',conn.hget(seller, 'funds'))
            return True
        except redis.exceptions.WatchError as e:
            print(e)
    return False

if __name__ == '__main__':
    conn = redis.Redis()
    #create_users(conn)
    #create_user_inventory(conn)
    list_item(conn,1,'ItemL',28)
    purchase_item(conn, 2, 'ItemL', 1)

# Save the DB on disk:
#  设置sedis进行数据库镜像的频率。
#  900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化）。
#  300秒（5分钟）内至少10个key值改变（则进行数据库保存--持久化）。
#  60秒（1分钟）内至少10000个key值改变（则进行数据库保存--持久化）。
save 900 1
save 300 10
save 60 10000

stop-writes-on-bgsave-error yes
# 在进行镜像备份时,是否进行压缩。yes：压缩，但是需要一些cpu的消耗。no：不压缩，需要更多的磁盘空间。
rdbcompression yes
# 一个CRC64的校验就被放在了文件末尾，当存储或者加载rbd文件的时候会有一个10%左右的性能下降，为了达到性能的最大化，你可以关掉这个配置项。
rdbchecksum yes
# 快照的文件名
dbfilename dump.rdb
# 存放快照的目录
dir ./

# 是否开启AOF，默认关闭（no）
appendonly yes
# 指定 AOF 文件名
appendfilename appendonly.aof
# Redis支持三种不同的刷写模式：
# appendfsync always #每次收到写命令就立即强制写入磁盘，是最有保证的完全的持久化，但速度也是最慢的，一般不推荐使用。
appendfsync everysec #每秒钟强制写入磁盘一次，在性能和持久化方面做了很好的折中，是受推荐的方式。
# appendfsync no     #完全依赖OS的写入，一般为30秒左右一次，性能最好但是持久化最没有保证，不被推荐。

#在日志重写时，不进行命令追加操作，而只是将其放在缓冲区里，避免与命令的追加造成DISK IO上的冲突。
#设置为yes表示rewrite期间对新写操作不fsync,暂时存在内存中,等rewrite完成后再写入，默认为no，建议yes
no-appendfsync-on-rewrite yes 
#当前AOF文件大小是上次日志重写得到AOF文件大小的二倍时，自动启动新的日志重写过程。
auto-aof-rewrite-percentage 100
#当前AOF文件启动新的日志重写过程的最小值，避免刚刚启动Reids时由于文件尺寸较小导致频繁的重写。
auto-aof-rewrite-min-size 64mb