为什么子类化Thread比调用Thread要慢得多？

Question

我有Python 2.7代码，它发出1,000个请求来检查我当前的IP地址。 我用200线程和套接字编写了它。 代码使用两种方法执行相同的任务。 我找不到下面两个之间的任何差异，除了那个子类threading.Thread

#!/usr/bin/env python2.7
import sys, ssl, time, socket, threading

class Counter:
    def __init__(self):
        self._value = 0
        self._LOCK = threading.Lock()

    def increment(self):
        with self._LOCK:
            self._value += 1
            return self._value

def pr(out):
    sys.stdout.write('{}\n'.format(out))
    sys.stdout.flush()

def recvAll(sock):
    data = ''
    BUF_SIZE = 1024

    while True:
        part = sock.recv(BUF_SIZE)
        data += part
        length = len(part)
        if length < BUF_SIZE: break

    return data

class Speed(threading.Thread):
    _COUNTER = Counter()

    def __init__(self):
        super(Speed, self).__init__()
        self.daemon = True
        self._sock = ssl.wrap_socket(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
        self._sock.settimeout(5)
        self._sock.connect(('checkip.amazonaws.com', 443))
        self._request = 'GET / HTTP/1.1\r\n'
        self._request += 'Host: checkip.amazonaws.com\r\n\r\n'

    def run(self):
        i = 0
        while i < 5:
            self._sock.write(self._request)
            response = recvAll(self._sock)
            if '200 OK' not in response: continue
            count = Speed._COUNTER.increment()
            pr('#{} - {}'.format(count, response))
            i += 1

        self._sock.close()

def speed():
    sock = ssl.wrap_socket(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
    sock.settimeout(5)
    sock.connect(('checkip.amazonaws.com', 443))
    request = 'GET / HTTP/1.1\r\n'
    request += 'Host: checkip.amazonaws.com\r\n\r\n'

    i = 0
    while i < 5:
        sock.write(request)
        response = recvAll(sock)
        if '200 OK' not in response: continue
        count = counter.increment()
        pr('#{} - {}'.format(count, response))
        i += 1

    sock.close()

slow = False

if slow:
    for _ in xrange(200):
        thread = Speed()
        thread.start()

else:
    counter = Counter()
    for _ in xrange(200):
        thread = threading.Thread(target = speed)
        thread.daemon = True
        thread.start()

while threading.active_count() > 1: time.sleep(1)

我希望两者都有相似的速度。 但是，子类threading.Thread的变化要慢很多很多。 任何想法为什么？

Answer 1

你的Thread子类在__init__做了太多的工作，它没有在新线程中执行。 因此，使用子类的版本最终会按顺序执行。