redis连接池归还

Administrator

2023-08-04 e5048ebdfa6b484c181693e77102845e05139735

redis连接池归还

 code_attribute/gpcode_manager.py

@@ -221,8 +221,8 @@
        RedisUtils.srem(self.__get_redis(), self.__redis_key, code)

    def sync(self):
        self.__want_buy_codes_cache.clear()
        codes = RedisUtils.smembers(self.__get_redis(), self.__redis_key)
        self.__want_buy_codes_cache.clear()
        if codes:
            self.__want_buy_codes_cache += set(codes)

@@ -242,33 +242,53 @@
# 暂停下单代码管理
# 与黑名单的区别是暂停交易代码只是不交易，不能移除L2监控位
class PauseBuyCodesManager:
    redisManager = redis_manager.RedisManager(0)
    __redis_key = "pause_buy_codes"
    __instance = None

    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(PauseBuyCodesManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.redisManager = redis_manager.RedisManager(0)
            cls.__instance.__redis_key = "pause_buy_codes"
            cls.__instance.__pause_buy_codes_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
                                                                         cls.__instance.__redis_key)
        return cls.__instance

    @classmethod
    def clear(cls):
        RedisUtils.delete(cls.__get_redis(), cls.__redis_key)
    def __get_redis(self):
        return self.redisManager.getRedis()

    @classmethod
    def add_code(cls, code):
        RedisUtils.sadd(cls.__get_redis(), cls.__redis_key, code)
        RedisUtils.expire(cls.__get_redis(), cls.__redis_key, tool.get_expire())
    def clear(self):
        self.__pause_buy_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), self.__redis_key)

    @classmethod
    def remove_code(cls, code):
        RedisUtils.srem(cls.__get_redis(), cls.__redis_key, code)
    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(),
                                   self.__redis_key)
        self.__pause_buy_codes_cache.clear()
        if data:
            self.__pause_buy_codes_cache |= data

    @classmethod
    def is_in(cls, code):
        return RedisUtils.sismember(cls.__get_redis(), cls.__redis_key, code)
    def add_code(self, code):
        self.__pause_buy_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), self.__redis_key, code)
        RedisUtils.expire(self.__get_redis(), self.__redis_key, tool.get_expire())

    @classmethod
    def list_code(cls):
        return RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)
    def remove_code(self, code):
        self.__pause_buy_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), self.__redis_key, code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), self.__redis_key, code)

    def is_in_cache(self, code):
        return code in self.__pause_buy_codes_cache

    def list_code(self):
        return RedisUtils.smembers(self.__get_redis(), self.__redis_key)

    def list_code_cache(self):
        return self.__pause_buy_codes_cache


def __parse_codes_data(code_datas):
@@ -425,9 +445,11 @@
        for d in gpset:
            RedisUtils.sadd(redis_instance, "gp_limit_up_list", json.dumps(d), auto_free=False)
        RedisUtils.expire(redis_instance, "gp_limit_up_list", tool.get_expire(), auto_free=False)
        RedisUtils.setex(redis_instance, "gp_limit_up_list_update_time", tool.get_expire(), round(time.time() * 1000), auto_free=False)
        RedisUtils.setex(redis_instance, "gp_limit_up_list_update_time", tool.get_expire(), round(time.time() * 1000),
                         auto_free=False)
    finally:
        RedisUtils.realse(redis_instance)


# 获取涨停列表
def get_limit_up_list():
@@ -450,7 +472,7 @@


def get_gp_list():
    codes = RedisUtils.smembers( __redisManager.getRedis(), "gp_list")
    codes = RedisUtils.smembers(__redisManager.getRedis(), "gp_list")
    first_codes = get_first_gp_codes()
    return set.union(codes, first_codes)

@@ -501,7 +523,7 @@
        codes = get_gp_list()
        if code not in codes and not FirstCodeManager().is_in_first_record_cache(code) and not force:
            return
        RedisUtils.setex( cls.__redisManager.getRedis(), "price-pre-{}".format(code), tool.get_expire(), str(price))
        RedisUtils.setex(cls.__redisManager.getRedis(), "price-pre-{}".format(code), tool.get_expire(), str(price))
        cls.__price_pre_cache[code] = float(price)


@@ -760,7 +782,7 @@

# 设置正在操作的代码
def set_operate(code):
    RedisUtils.setex( __redisManager.getRedis(), "gp_operate-{}".format(code), 30, "1")
    RedisUtils.setex(__redisManager.getRedis(), "gp_operate-{}".format(code), 30, "1")


# 批量设置正在操作的代码

 inited_data.py

@@ -80,13 +80,13 @@
        # 删除禁止代码
        l2_trade_util.init_forbidden_trade_codes()
        # 清空白名单
        l2_trade_util.WhiteListCodeManager.clear()
        l2_trade_util.WhiteListCodeManager().clear()
        # 清空想要买
        gpcode_manager.WantBuyCodesManager().clear()
        # 清空分数禁止代码
        trade_manager.ForbiddenBuyCodeByScoreManager().clear()
        # 清空暂停交易代码
        gpcode_manager.PauseBuyCodesManager.clear()
        gpcode_manager.PauseBuyCodesManager().clear()
        # 清除L撤数据
        LCancelBigNumComputer.clear()
        # 清除D撤数据

 l2/l2_data_manager_new.py

@@ -617,7 +617,7 @@
    def __can_cancel(cls, code):
        if constant.TEST:
            return True, ""
        if l2_trade_util.WhiteListCodeManager.is_in(code):
        if l2_trade_util.WhiteListCodeManager().is_in_cache(code):
            return False, "代码在白名单中"

        # 暂时注释掉
@@ -651,7 +651,7 @@
    @classmethod
    def __can_buy(cls, code):
        __start_time = t.time()
        if not trade_manager.TradeStateManager.is_can_buy():
        if not trade_manager.TradeStateManager().is_can_buy_cache():
            return False, True, f"今日已禁止交易"
        # 之前的代码
        # 首板代码且尚未涨停过的不能下单
@@ -778,10 +778,10 @@

    @classmethod
    def __can_buy_first(cls, code):
        if not trade_manager.TradeStateManager.is_can_buy():
        if not trade_manager.TradeStateManager().is_can_buy_cache():
            return False, True, f"今日已禁止交易"

        if gpcode_manager.PauseBuyCodesManager.is_in(code):
        if gpcode_manager.PauseBuyCodesManager().is_in_cache(code):
            return False, True, f"该代码被暂停交易"

        limit_up_price = gpcode_manager.get_limit_up_price(code)
@@ -864,7 +864,7 @@
                                      cls.__l2PlaceOrderParamsManagerDict[code].score_info)

        if not gpcode_manager.WantBuyCodesManager().is_in_cache(code):
            if TradeTargetCodeModeManager.get_mode() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
            if TradeTargetCodeModeManager().get_mode_cache() == TradeTargetCodeModeManager.MODE_ONLY_BUY_WANT_CODES:
                return False, True, f"只买想买单中的代码"
            score_index = cls.__l2PlaceOrderParamsManagerDict[code].score_index
            score = cls.__l2PlaceOrderParamsManagerDict[code].score

 main.py

@@ -13,7 +13,7 @@
from trade.huaxin import trade_server, trade_api_server


def createTradeServer():
def createTradeServer(pipe):
    # 初始化参数
    global_data_loader.init()

@@ -22,7 +22,7 @@
    t1.start()

    # 交易接口服务
    t1 = threading.Thread(target=trade_api_server.run, daemon=True)
    t1 = threading.Thread(target=trade_api_server.run, args=(pipe,), daemon=True)
    t1.start()

    # 交易服务
@@ -30,10 +30,10 @@


# 主服务
def createServer():
def createServer(pipe):
    print("create Server")
    laddr = "", 9001
    tcpserver = MyThreadingTCPServer(laddr, MyBaseRequestHandle, pipe_juejin=None)  # 注意：参数是MyBaseRequestHandle
    tcpserver = MyThreadingTCPServer(laddr, MyBaseRequestHandle, pipe_trade=pipe)  # 注意：参数是MyBaseRequestHandle
    # tcpserver.handle_request()  # 只接受一个客户端连接
    tcpserver.serve_forever()  # 永久循环执行,可以接受多个客户端连接

@@ -45,8 +45,9 @@


if __name__ == '__main__':
    pipe_server, pipe_trade = multiprocessing.Pipe()
    logger_l2_process_time.info("测试123")
    serverProcess = multiprocessing.Process(target=createServer)
    serverProcess = multiprocessing.Process(target=createServer, args=(pipe_server,))
    serverProcess.start()
    # 将tradeServer作为主进程
    createTradeServer()
    createTradeServer(pipe_trade)

 output/code_info_output.py

@@ -82,12 +82,12 @@
    code_extra_infos = []
    if l2_trade_util.BlackListCodeManager().is_in_cache(code):
        code_extra_infos.append("黑名单")
    if l2_trade_util.WhiteListCodeManager.is_in(code):
    if l2_trade_util.WhiteListCodeManager().is_in_cache(code):
        code_extra_infos.append("白名单")
    # 获取白名单,黑名单
    if code_attribute.gpcode_manager.WantBuyCodesManager().is_in_cache(code):
        code_extra_infos.append("想买单")
    if code_attribute.gpcode_manager.PauseBuyCodesManager.is_in(code):
    if code_attribute.gpcode_manager.PauseBuyCodesManager().is_in_cache(code):
        code_extra_infos.append("暂不买")
    params["code"] = code
    params["code_name"] = f"{gpcode_manager.get_code_name(code)} {code}  （{','.join(code_extra_infos)}）"

 server.py

@@ -43,8 +43,8 @@


class MyTCPServer(socketserver.TCPServer):
    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True, pipe_juejin=None, pipe_ui=None):
        self.pipe_juejin = pipe_juejin  # 增加的参数
    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True, pipe_trade=None, pipe_ui=None):
        self.pipe_trade = pipe_trade  # 增加的参数
        self.pipe_ui = pipe_ui
        # 初始化数据
        block_info.init()
@@ -81,8 +81,12 @@
    def setup(self):
        super().setup()  # 可以不调用父类的setup()方法，父类的setup方法什么都没做
        # print("----setup方法被执行-----")
        # print("打印传入的参数：", self.server.pipe)
        # print("打印传入的参数：", self.server.pipe_trade)
        self.l2CodeOperate = l2_code_operate.L2CodeOperate.get_instance()

    def __notify_trade(self, type_):
        if self.server.pipe_trade:
            self.server.pipe_trade.send(json.dumps({"type": type_}))

    def handle(self):
        host = self.client_address[0]
@@ -275,7 +279,7 @@
                            raise Exception('未到接受时间')
                        # 首板代码
                        dataList, is_add = data_process.parseGPCode(_str)
                        tick_datas =  first_target_code_data_processor.process_first_codes_datas(dataList)
                        tick_datas = first_target_code_data_processor.process_first_codes_datas(dataList)
                        # 保存现价
                        self.first_tick_datas.clear()
                        self.first_tick_datas.extend(tick_datas)
@@ -664,6 +668,7 @@
                                gpcode_manager.CodesNameManager.add_first_code_name(code, results[code])

                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("black_list")
                elif type == 202:
                    # 加入白名单
                    data = json.loads(_str)
@@ -681,7 +686,7 @@
                            # if zyltgb > 50 * 100000000:
                            #     raise Exception("自由流通股本大于50亿")

                            l2_trade_util.WhiteListCodeManager.add_code(code)
                            l2_trade_util.WhiteListCodeManager().add_code(code)
                            name = gpcode_manager.get_code_name(code)
                            if not name:
                                results = HistoryKDatasUtils.get_gp_codes_names([code])
@@ -690,6 +695,7 @@
                        return_str = json.dumps({"code": 0})
                    except Exception as e:
                        return_str = json.dumps({"code": 1, "msg": str(e)})
                    self.__notify_trade("white_list")

                elif type == 203:
                    # 移除黑名单
@@ -698,13 +704,15 @@
                    for code in codes:
                        l2_trade_util.remove_from_forbidden_trade_codes(code)
                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("black_list")
                elif type == 204:
                    # 移除白名单
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        l2_trade_util.WhiteListCodeManager.remove_code(code)
                        l2_trade_util.WhiteListCodeManager().remove_code(code)
                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("white_list")
                elif type == 301:
                    # 黑名单列表
                    codes = l2_trade_util.BlackListCodeManager().list_codes()
@@ -715,12 +723,13 @@
                    return_str = json.dumps({"code": 0, "data": datas})
                elif type == 302:
                    # 黑名单列表
                    codes = l2_trade_util.WhiteListCodeManager.list_codes()
                    codes = l2_trade_util.WhiteListCodeManager().list_codes()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
                        datas.append(f"{name}:{code}")
                    return_str = json.dumps({"code": 0, "data": datas})

                elif type == 401:
                    # 加入想要买
                    data = json.loads(_str)
@@ -737,12 +746,14 @@
                            self.__KPLCodeLimitUpReasonManager.save_reason(codes[i], data["data"]["plates"][i])

                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("want_list")
                elif type == 402:
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        gpcode_manager.WantBuyCodesManager().remove_code(code)
                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("want_list")
                elif type == 403:
                    plate = None
                    include_codes = set()
@@ -768,25 +779,27 @@
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        gpcode_manager.PauseBuyCodesManager.add_code(code)
                        gpcode_manager.PauseBuyCodesManager().add_code(code)
                        name = gpcode_manager.get_code_name(code)
                        if not name:
                            results = HistoryKDatasUtils.get_gp_codes_names([code])
                            if results:
                                gpcode_manager.CodesNameManager.add_first_code_name(code, results[code])
                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("pause_buy_list")
                    # 加入暂停买入列表
                elif type == 412:
                    # 移除暂停买入列表
                    data = json.loads(_str)
                    codes = data["data"]["codes"]
                    for code in codes:
                        gpcode_manager.PauseBuyCodesManager.remove_code(code)
                        gpcode_manager.PauseBuyCodesManager().remove_code(code)
                    return_str = json.dumps({"code": 0})
                    self.__notify_trade("pause_buy_list")

                elif type == 413:
                    # 暂停买入列表
                    codes = gpcode_manager.PauseBuyCodesManager.list_code()
                    codes = gpcode_manager.PauseBuyCodesManager().list_code()
                    datas = []
                    for code in codes:
                        name = gpcode_manager.get_code_name(code)
@@ -811,9 +824,9 @@
                    # 查询是否想买单/白名单/黑名单/暂不买
                    code_name = gpcode_manager.get_code_name(code)
                    want = gpcode_manager.WantBuyCodesManager().is_in_cache(code)
                    white = l2_trade_util.WhiteListCodeManager.is_in(code)
                    white = l2_trade_util.WhiteListCodeManager().is_in_cache(code)
                    black = l2_trade_util.is_in_forbidden_trade_codes(code)
                    pause_buy = gpcode_manager.PauseBuyCodesManager.is_in(code)
                    pause_buy = gpcode_manager.PauseBuyCodesManager().is_in_cache(code)

                    desc_list = []
                    if want:
@@ -832,25 +845,27 @@
                    data = json.loads(_str)
                    is_open = data["data"]["open"]
                    if is_open:
                        trade_manager.TradeStateManager.open_buy()
                        trade_manager.TradeStateManager().open_buy()
                    else:
                        trade_manager.TradeStateManager.close_buy()
                        trade_manager.TradeStateManager().close_buy()
                    return_str = json.dumps({"code": 0, "msg": ("开启成功" if is_open else "关闭成功")})
                    self.__notify_trade("trade_state")
                elif type == 502:
                    can_buy = trade_manager.TradeStateManager.is_can_buy()
                    can_buy = trade_manager.TradeStateManager().is_can_buy_cache()
                    return_str = json.dumps({"code": 0, "data": {"can_buy": can_buy}})
                elif type == 503:
                    # 设置交易目标代码的模式
                    data = json.loads(_str)
                    mode = data["data"]["mode"]
                    try:
                        TradeTargetCodeModeManager.set_mode(mode)
                        TradeTargetCodeModeManager().set_mode(mode)
                        return_str = json.dumps({"code": 0, "data": {"mode": mode}})
                    except Exception as e:
                        return_str = json.dumps({"code": 1, "msg": str(e)})
                    self.__notify_trade("trade_mode")
                elif type == 504:
                    # 获取交易目标代码模式
                    mode = TradeTargetCodeModeManager.get_mode()
                    mode = TradeTargetCodeModeManager().get_mode_cache()
                    return_str = json.dumps({"code": 0, "data": {"mode": mode}})
                elif type == 601:
                    pass

 third_data/data_server.py

@@ -564,7 +564,7 @@
    pass


def run(addr, port):
def run(pipe_trade,addr, port):
    # 运行看盘消息采集
    kp_client_msg_manager.run_capture()
    handler = DataServer

 trade/huaxin/trade_api_server.py

@@ -18,10 +18,11 @@
from third_data.history_k_data_util import HistoryKDatasUtils, JueJinApi
from third_data.kpl_data_manager import KPLDataManager
from third_data.kpl_util import KPLDataType
from trade import trade_manager, trade_huaxin
from trade import trade_manager, trade_huaxin, l2_trade_util

from trade.huaxin import huaxin_trade_api, huaxin_trade_record_manager, \
    huaxin_trade_data_update
from trade.trade_manager import TradeTargetCodeModeManager
from utils import socket_util, tool, huaxin_util, data_export_util


@@ -331,7 +332,7 @@

                        try:
                            # 验证redis
                            RedisUtils.get(redis_manager.RedisManager(0).getRedis(),"test")
                            RedisUtils.get(redis_manager.RedisManager(0).getRedis(), "test")
                            fdata["redis"] = 1
                        except:
                            fdata["redis"] = 0
@@ -355,11 +356,11 @@
                            _start_time = time.time()
                            times = []
                            for i in range(0, 100):
                                RedisUtils.sadd(redis, "test_set", f"000000:{i}",auto_free=False)
                                RedisUtils.sadd(redis, "test_set", f"000000:{i}", auto_free=False)
                            times.append(time.time() - _start_time)
                            _start_time = time.time()
                            for i in range(0, 20):
                                RedisUtils.smembers(redis, "test_set",auto_free=False)
                                RedisUtils.smembers(redis, "test_set", auto_free=False)
                            times.append(time.time() - _start_time)
                            return_str = json.dumps(
                                {"code": 0, "data": times, "msg": ""})
@@ -434,7 +435,52 @@
            time.sleep(1)


def run():
def __read_sync_task(pipe):
    while True:
        try:
            if pipe:
                val = pipe.recv()
                if val:
                    print("接收到更新任务：", val)
                    val = json.loads(val)
                    type_ = val["type"]
                    if type_ == "want_list":
                        print("want_list before", gpcode_manager.WantBuyCodesManager().list_code_cache())
                        gpcode_manager.WantBuyCodesManager().sync()
                        print("want_list after",gpcode_manager.WantBuyCodesManager().list_code_cache())
                    elif type_ == "white_list":
                        print("white_list before", l2_trade_util.WhiteListCodeManager().list_code_cache())
                        l2_trade_util.WhiteListCodeManager().sync()
                        print("white_list after", l2_trade_util.WhiteListCodeManager().list_code_cache())
                    elif type_ == "black_list":
                        print("black_list before", l2_trade_util.BlackListCodeManager().list_code_cache())
                        l2_trade_util. BlackListCodeManager().sync()
                        print("black_list after", l2_trade_util.BlackListCodeManager().list_code_cache())
                    elif type_ == "pause_buy_list":
                        print("pause_buy_list before", gpcode_manager.PauseBuyCodesManager().list_code_cache())
                        gpcode_manager.PauseBuyCodesManager().sync()
                        print("pause_buy_list after", gpcode_manager.PauseBuyCodesManager().list_code_cache())
                    elif type_ == "trade_state":
                        print("trade_state before", trade_manager.TradeStateManager().is_can_buy_cache())
                        trade_manager.TradeStateManager().sync()
                        print("trade_state after", trade_manager.TradeStateManager().is_can_buy_cache())
                    elif type_ == "trade_mode":
                        print("trade_mode before", trade_manager.TradeTargetCodeModeManager().get_mode_cache())
                        trade_manager.TradeTargetCodeModeManager().sync()
                        print("trade_mode after", trade_manager.TradeTargetCodeModeManager().get_mode_cache())






        except Exception as e:
            logging.exception(e)
        finally:
            time.sleep(1)


def run(pipe):
    print("create TradeApiServer")
    # 拉取交易信息
    huaxin_trade_data_update.run()
@@ -442,6 +488,9 @@
    t1 = threading.Thread(target=lambda: __set_target_codes(), daemon=True)
    t1.start()

    t1 = threading.Thread(target=lambda: __read_sync_task(pipe), daemon=True)
    t1.start()

    laddr = "0.0.0.0", 10009
    tcpserver = MyThreadingTCPServer(laddr, MyBaseRequestHandle)  # 注意：参数是MyBaseRequestHandle
    tcpserver.serve_forever()

 trade/l2_trade_util.py

@@ -7,32 +7,51 @@


class WhiteListCodeManager:
    __redis_manager = redis_manager.RedisManager(2)
    __instance = None

    @classmethod
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WhiteListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__redis_manager = redis_manager.RedisManager(2)
            cls.__instance.__white_codes_cache = RedisUtils.smembers(cls.__instance.__get_redis(), "white_list_codes")

    @classmethod
    def add_code(cls, code):
        RedisUtils.sadd(cls.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(cls.__get_redis(), "white_list_codes", tool.get_expire())
        return cls.__instance

    @classmethod
    def remove_code(cls, code):
        RedisUtils.srem(cls.__get_redis(), "white_list_codes", code)
    def __get_redis(self):
        return self.__redis_manager.getRedis()

    @classmethod
    def is_in(cls, code):
        return RedisUtils.sismember(cls.__get_redis(), "white_list_codes", code)
    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(), "white_list_codes")
        self.__white_codes_cache.clear()
        if data:
            self.__white_codes_cache |= data

    @classmethod
    def list_codes(cls):
        return RedisUtils.smembers(cls.__get_redis(), "white_list_codes")
    def add_code(self, code):
        self.__white_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(self.__get_redis(), "white_list_codes", tool.get_expire())

    @classmethod
    def clear(cls):
        RedisUtils.delete(cls.__get_redis(), "white_list_codes")
    def remove_code(self, code):
        self.__white_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "white_list_codes", code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "white_list_codes", code)

    def is_in_cache(self, code):
        return code in self.__white_codes_cache

    def list_codes(self):
        return RedisUtils.smembers(self.__get_redis(), "white_list_codes")

    def list_codes_cache(self):
        return self.__white_codes_cache

    def clear(self):
        self.__white_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "white_list_codes")


class BlackListCodeManager:
@@ -57,6 +76,13 @@
        RedisUtils.sadd(self.__get_redis(), "forbidden-trade-codes", code)
        RedisUtils.expire(self.__get_redis(), "forbidden-trade-codes", tool.get_expire())

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(),
                                   "forbidden-trade-codes")
        self.__forbidden_trade_codes_cache.clear()
        if data:
            self.__forbidden_trade_codes_cache |= data

    def remove_code(self, code):
        self.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "forbidden-trade-codes", code)
@@ -71,6 +97,9 @@
        codes = RedisUtils.smembers(self.__get_redis(), "forbidden-trade-codes")
        self.__forbidden_trade_codes_cache = codes
        return codes

    def list_codes_cache(self):
        return self.__forbidden_trade_codes_cache

    def clear(self):
        self.__forbidden_trade_codes_cache.clear()
@@ -106,4 +135,4 @@

if __name__ == "__main__":
    # add_to_forbidden_trade_codes("000977")
    WhiteListCodeManager.add_code("002977")
    WhiteListCodeManager().add_code("002977")

 trade/trade_manager.py

@@ -46,33 +46,50 @@
# 关闭购买入口
# 开启购买入口
class TradeStateManager:

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(TradeStateManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.redisManager = redis_manager.RedisManager(2)
            cls.__instance.__trade_buy_state_cache = cls.__instance.is_can_buy_cache()
        return cls.__instance

    redisManager = redis_manager.RedisManager(2)

    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()
    def __get_redis(self):
        return self.redisManager.getRedis()

    def sync(self):
        self.__trade_buy_state_cache = self.is_can_buy_cache()

    # 开启购买入口
    @classmethod
    def open_buy(cls):
        RedisUtils.setex(cls.__get_redis(), "trade_buy_state", tool.get_expire(), 1)
    def open_buy(self):
        self.__trade_buy_state_cache = True
        RedisUtils.setex(self.__get_redis(), "trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    @classmethod
    def close_buy(cls):
        RedisUtils.setex(cls.__get_redis(), "trade_buy_state", tool.get_expire(), 0)
    def close_buy(self):
        self.__trade_buy_state_cache = False
        RedisUtils.setex(self.__get_redis(), "trade_buy_state", tool.get_expire(), 0)

    # 是否可以下单
    @classmethod
    def is_can_buy(cls):
    def is_can_buy(self):
        # 默认设置为可交易
        val = RedisUtils.get(cls.__get_redis(), "trade_buy_state")
        val = RedisUtils.get(self.__get_redis(), "trade_buy_state")
        if val is None:
            return True
        if int(val) == 1:
            return True
        else:
            return False

        # 是否可以下单

    def is_can_buy_cache(self):
        # 默认设置为可交易
        return self.__trade_buy_state_cache


# 交易目标票模式
@@ -82,27 +99,41 @@
    # 买所有
    MODE_BUY_ALL = 0

    redisManager = redis_manager.RedisManager(2)
    __instance = None

    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(TradeTargetCodeModeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.redisManager = redis_manager.RedisManager(2)
            cls.__instance.__trade_buy_mode_cache = cls.__instance.get_mode_cache()
        return cls.__instance

    def __get_redis(self):
        return self.redisManager.getRedis()

    # 开启购买入口
    @classmethod
    def set_mode(cls, mode):
        if mode != cls.MODE_ONLY_BUY_WANT_CODES and mode != cls.MODE_BUY_ALL:

    def sync(self):
        self.__trade_buy_mode_cache = self.get_mode_cache()

    def set_mode(self, mode):
        if mode != self.MODE_ONLY_BUY_WANT_CODES and mode != self.MODE_BUY_ALL:
            raise Exception("mode参数值错误")
        RedisUtils.setex(cls.__get_redis(), "trade_buy_mode", tool.get_expire(), mode)
        self.__trade_buy_mode_cache = mode
        RedisUtils.setex(self.__get_redis(), "trade_buy_mode", tool.get_expire(), mode)

    # 是否可以下单
    @classmethod
    def get_mode(cls):
    def get_mode(self):
        # 默认设置为可交易
        val = RedisUtils.get(cls.__get_redis(), "trade_buy_mode")
        val = RedisUtils.get(self.__get_redis(), "trade_buy_mode")
        if val is None:
            return cls.MODE_BUY_ALL
            return self.MODE_BUY_ALL
        return int(val)

    def get_mode_cache(self):
        return self.__trade_buy_mode_cache


# 根据分数禁止买的票管理
@@ -151,7 +182,7 @@
# 设置交易状态
def set_trade_state(code, state):
    logger_trade.info("set_trade_state {}-{}".format(code, state))
    RedisUtils.setex( __redis_manager.getRedis(), "trade-state-{}".format(code), tool.get_expire(), state)
    RedisUtils.setex(__redis_manager.getRedis(), "trade-state-{}".format(code), tool.get_expire(), state)


def get_codes_by_trade_state(state):