Question

我想线程有一些局部变量，thread.Thread它可以像这样优雅地完成：

class TTT(threading.Thread):
    def __init__(self, lines, ip, port):
        threading.Thread.__init__(self)
        self._lines = lines;
        self._sock = initsock(ip, port)
        self._sts = 0
        self._cts = 0

    def run(self):
        for line in self._lines:
            query = genquery(line)
            length = len(query)
            head = "0xFFFFFFFE"
            q = struct.pack('II%ds'%len(query),  head,  length, query)
            sock.send(q)
            sock.recv(4)
            length,  = struct.unpack('I',  sock.recv(4))
            result = ''
            remain = length
            while remain:
                t = sock.recv(remain)
                result+=t
                remain-=len(t)
            print(result)

您可以看到_lines _sock _sts _cts这些变量在每个帖子中都是独立的。

但是concurrent.future.ThreadPoolExecutor，似乎并不那么容易。使用ThreadPoolExecutor，我怎样才能优雅地制作东西？（不再有全局变量）

新编辑

class Processor(object):
    def __init__(self, host, port):
        self._sock = self._init_sock(host, port)

    def __call__(self, address, adcode):
        self._send_data(address, adcode)
        result = self._recv_data()
        return json.loads(result)

def main():
    args = parse_args()
    adcode = {"shenzhen": 440300}[args.city]

    if args.output:
        fo = open(args.output, "w", encoding="utf-8")
    else:
        fo = sys.stdout
    with open(args.file, encoding=args.encoding) as fi, fo,\
        ThreadPoolExecutor(max_workers=args.processes) as executor:
        reader = csv.DictReader(fi)
        writer = csv.DictWriter(fo, reader.fieldnames + ["crfterm"])
        test_set = AddressIter(args.file, args.field, args.encoding)
        func = Processor(args.host, args.port)
        futures = map(lambda x: executor.submit(func, x, adcode), test_set)
        for row, future in zip(reader, as_completed(futures)):
            result = future.result()
            row["crfterm"] = join_segs_tags(result["segs"], result["tags"])
            writer.writerow(row)

Answer 1

使用与现在非常相似的布局将是最简单的事情。不是Thread，而是使用普通对象，而不是run，而是在__call__中实现您的逻辑：

class TTT:
    def __init__(self, lines, ip, port):
        self._lines = lines;
        self._sock = initsock(ip, port)
        self._sts = 0
        self._cts = 0

    def __call__(self):
        ...
        # do stuff to self

向类添加__call__方法可以调用实例，就好像它们是常规函数一样。实际上，普通函数是具有这种方法的对象。您现在可以将一堆TTT个实例传递给map或submit。

或者，您可以将初始化吸收到任务函数中：

def ttt(lines, ip, port):
    sock = initsock(ip, port)
    sts = cts = 0
    ...

现在，您可以使用正确的参数列表调用submit，或使用每个参数的可迭代值调用map。

我更喜欢这个例子的前一种方法，因为它打开了执行程序之外的端口。执行程序任务中的错误报告有时会很棘手，我更倾向于使打开端口的错误操作尽可能透明。

修改

根据你的相关问题，我相信你问的真正问题是关于函数局部变量（它们也是自动线程局部的），而不是在同一线程上的函数调用之间共享。但是，您始终可以在函数调用之间传递引用。

如何在ThreadPoolExecutor中使用threadlocal变量？

1 个答案: