python日记(一)：为什么我的多线程速度反而不如单线程？

Background(废话，可以跳过不看)

今天使用在实际操作中，需要求一个矩阵中每个结点对之间相似度，矩阵的大小大概有17000+，所以一共需要计算结点对17000×17000=？？？？？辣么老多个。计算了一下大概需要三个小时以上。
然后就想到了以前用过的多线程爬虫，简直爽到飞起，所以想着用多线程可以是不是可以提高循环计算的速度？然后就动手写了一个多线程，但是发现速度甚至不及单线程，甚至还要更慢。Excuse Me？？？？
然后就去查看了一下别的大佬怎么讲。

python线程原理（敲黑板）

下面引入一个概念GIL。我们看官方给出的解释：

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)
这个东西本身就是一个全局的线程锁，因为python的内存管理不是线程安全的，所以GIL被用来防止多个本机线程同时执行Python字节码。简单明了地说，python好像对多线程是不太友好的。
接下来我们使用代码去验证：

weights = []
 row = []
 col = []
 lock = threading.Lock()   # 申请线程锁
 time1 = time.time()
 def thread_cal_cosine(start,end):
     for i in list(struct_vocab.keys())[start:end]:
         for j in list(struct_vocab.keys()):
             if i == j:   # 跳过自环
                 continue
             weight = 1 - cosine(struct_vocab[i], struct_vocab[j])   # 1-余弦距离才是余弦相似度
             if weight > 0.9:   # 这个参数是TextGCN里提到的
                 lock.acquire()   # 变量加锁
                 weights.append(weight)
                 row.append(i)
                 col.append(j)
                 lock.release()
 threads = []
 for index in range(0, 20, 5):
     start = index
     end = index + 5
     threads.append(threading.Thread(target=thread_cal_cosine, args=(start, end)))
 for each in threads:
     each.start()
     each.join()
     print('线程' + str(each) + '执行')

 print('len weights:', len(weights))
 struct_adj = sp.csr_matrix(
     (weights, (row, col)), shape=(len(vocabs), len(vocabs)))
 # io.mmwrite(path + '{}.struct.adj.mtx'.format(dataset), struct_adj)
 # print(path + '{}.struct.adj.mtx'.format(dataset), struct_adj)   # 稀疏矩阵特殊的存放数据方法
print('用时：', time.time() - time1)

我为结点之间相似度的计算添加了线程。为了执行效果快，我只截取了第一个for循环的前20个，实际上有17000+，最终用时：

用时： 12.304814100265503

接下来再来看单线程的：

time1 = time.time()
for i in list(struct_vocab.keys())[0:20]:
    for j in list(struct_vocab.keys()):
        if i == j:   # 跳过自环
            continue
        weight = 1 - cosine(struct_vocab[i], struct_vocab[j])   # 1-余弦距离才是余弦相似度
        if weight > 0.9:   # 这个参数是TextGCN里提到的
            weights.append(weight)
            row.append(i)
            col.append(j)

print('len weights:', len(weights))
struct_adj = sp.csr_matrix(
    (weights, (row, col)), shape=(len(vocabs), len(vocabs)))
# io.mmwrite(path + '{}.struct.adj.mtx'.format(dataset), struct_adj)
# print(path + '{}.struct.adj.mtx'.format(dataset), struct_adj)   # 稀疏矩阵特殊的存放数据方法
print('用时：', time.time() - time1)

用时： 12.467553615570068

这根本没差嘛！从原理上解释，尽管CPU是多核的，理论上可以执行多线程的任务。但是由于python GIL的机制，多线程并无法抢占多余的计算资源，并且在线程调度的过程中，也可能造成时间的浪费。这就使得在多线程执行的时候，效果甚至可能比单线程要慢！！！！
但是，以上缺陷只对于计算密集型任务来说，对于爬虫这种请求密集或是文件读写这种IO密集的任务，多线程还是能很好地胜任的。因为每个线程执行的时候都是在请求外部的资源，而非CPU内部的计算，线程执行之后需要很久，外部任务（比如HTTP请求）才会完成，CPU有充分的时间完成线程的切换。
所以，一句话总结：
在进行数值计算的时候，python的多线程很拉跨；在进行网络爬虫，文件读写的时候，多线程又能排上很大用场。