---

第1关：持久化

1、创建快照的方式有：

A、执行 SAVE 命令

B、执行 BESAVE 命令

C、使用 save 选项配置自动快照

D、通过客户端发送关闭服务器请求

E、以上均可

2、AOF 持久化中，最佳的同步策略是：

A、everysec

B、no

C、yes

D、always

3、下面是配置文件 redis.conf 中的一个重写 AOF 配置：

auto-aof-rewrite-percentage 120
auto-aof-rewrite-min-size 512mb
请问这个配置代表什么意思？

A、当目前 AOF 文件大小超过上一次重写后的文件大小的 120% 时进行重写

B、当目前 AOF 文件大小是上一次重写后的文件大小的 120% 时进行重写

C、当目前 AOF 文件超过 512mb 后进行重写

D、当目前 AOF 文件超过上一次重写后的文件大小 512mb 时进行重写

E、以上选项均不正确

4、假设有这样一个系统，该系统：
接收并处理用户的订票请求
对机票的库存信息进行实时刷新
机票出票要求：
机票有库存
用户已付款
用户量在1000万以上，每日订单量在5000千万以上
使用 Redis 存储用户，机票，订单等信息
所有数据要求保留一年以上
请问该系统应该选择怎样的持久化方法？

A、单RDB持久化

B、单AOF持久化

C、同时开启RDB持久化与AOF持久化

D、不使用持久化

第2关：复制

1、某 Redis 实例已启动，现想将其变成：

主机地址为 127.0.0.1
端口号为 6381
的 Redis 实例的从数据库，应该输入哪条命令？

A、SLAVEOF no one

B、SLAVEOF 127.0.0.1 6381

C、redis-server --port 6380 --slaveof 127.0.0.1 6381

D、SLAVEOF host port

2、现有一组主从数据库，其主数据库为 127.0.0.1:6379，从数据库为 127.0.0.1:6380。依次执行下列操作：

（主数据库中）LPUSH email:queue jack bob josiah
（从数据库中）RPOP email:queue
（从数据库中）LPUSH email:queue david
（主数据库中）LPUSH email:queue sam
该主从数据库中，主数据库负责写，从数据库负责读，采用默认配置，请问现在主数据库中的 email:queue 队列内的元素顺序如何（从左至右）？

A、sam josiah bob jack

B、jack bob josiah sam

C、david josiah bob

D、jack bob david

3、下列说法中正确的是？

A、从数据库都是只读的

B、在复制初始化过程中，主数据库接收到从数据库发来的 SYNC 命令后，可能会执行 BESAVE 命令，也可能不执行

C、Redis 的主从复制，主数据库与从数据库之间始终都不同步

D、主从链的作用是加快主数据库同步到多个从数据库的速度

E、终止主从关系后，主从数据库之间不再进行复制同步

4、在一对主从数据库中，主数据库关闭了所有持久化配置，从数据库打开了 AOF 持久化，以每秒一次的速度向硬盘追加写入 AOF 文件。现在主数据库因断电关闭，要恢复到断电前的工作状态，应该如何操作？

A、快速重启主数据库

B、快速重启主数据库，并在主数据库上执行 SYNC 命令，请求同步数据

C、终止从数据库与主数据库的主从关系，重启原来的主数据库，并将其设置为新的主数据库的从数据库

D、重启主数据库并开启持久化配置

第3关：Redis事务与流水线

根据提示，在右侧Begin-End区域补充代码，完成商品交易平台的后端处理逻辑：

请在下述两个方法中均使用非事务性流水线减少通信往返次数。
在 add_item_to_market(itemid, sellerid, price) 方法中：
该方法作用是：用户将商品加入到买卖平台上
参数说明：
itemid 是商品 ID
sellerid 是卖家 ID
price 是商品价格。
该过程描述及返回值描述：
卖家拥有该商品。
扣除卖家商品成功
从用户仓库中扣除该商品。
将商品加入到商品买卖信息有序集合中。
返回 True

• 扣除卖家商品失败
  • 在 5 秒内重试加入事务。
    重试失败，返回 False
    卖家不拥有该商品。
    不允许将商品加入平台。
    返回 None
    在 purchase(buyerid, itemid) 方法中：
    该方法作用是：用户从买卖平台上购买商品
    参数说明：
    buyerid 是买家 ID
    itemid 是商品买卖信息中的成员，格式是 itemX.userX，其中：
    itemX 是商品 ID
    userX 是卖家 ID
    该过程描述及返回值描述：
    买家在购买其他商品/该商品已被其他用户买走：
    在 10 秒内重试购买事务。
    重试失败，返回 False
    买家未同时购买其他商品，该商品仍在平台上：
    买家用户余额是否足够购买该商品，若足够：
    买家用户余额减去商品价格的数值。
    卖家用户余额增加商品价格的数值。
    从商品买卖信息有序集合中移除该商品。
    为买家用户仓库增加该商品。
    返回 True
    若不足够：
    终止交易。
    返回 None
    测试说明
    

代码示例如下：

#!/usr/bin/env python  
#-*- coding:utf-8 -*-
import time  
import redis
conn = redis.Redis()
# 将商品放到平台上  
def add_item_to_market(itemid, sellerid, price):  
    # 请在下面完成要求的功能  
    #********* Begin *********#  
    repertory = "inventory:" + sellerid  
    item = itemid + "." + sellerid  
    end = time.time() + 5  
    pipe = conn.pipeline()
    while time.time() < end:  
        try:  
            pipe.watch(repertory)  
            if not pipe.sismember(repertory, itemid):  
                pipe.unwatch()  
                return None  
            pipe.multi()  
            pipe.zadd("market", item, price)  
            pipe.srem(repertory, itemid)  
            pipe.execute()  
            return True  
        except redis.exceptions.WatchError:  
            pass  
    return False  
    #********* End *********#
# 购买商品  
def purchase(buyerid, itemid):  
    # 请在下面完成要求的功能  
    #********* Begin *********#  
    item, sellerid = itemid.split(".")  
    buyer = "users:" + buyerid  
    seller = "users:" + sellerid  
    repertory = "inventory:" + buyerid  
    end = time.time() + 10  
    pipe = conn.pipeline()
    while time.time() < end:  
        try:  
            pipe.watch("market", buyer)  
            price = pipe.zscore("market", itemid)  
            funds = int(pipe.hget(buyer, "funds"))  
            if funds < price:  
                pipe.unwatch()  
                return None
            pipe.multi()  
            pipe.hincrby(seller, "funds", int(price))  
            pipe.hincrby(buyer, "funds", int(-price))  
            pipe.sadd(repertory, item)  
            pipe.zrem("market", itemid)  
            pipe.execute()  
            return True  
        except redis.exceptions.WatchError:  
            pass  
    return False  
    #********* End *********#  

---