线程相关知识

线程理论

进程
	进程其实是资源单位，表示一块内存空间
线程
	线程才是执行单位，表示真正的代码指令

我们可以将进程比喻是车间，线程是车间里面的流水线
一个进程内部至少含有一个线程

1.一个进程内可以开设多个线程
2.同一个进程下的多个线程数据是共享的
3.创建进程与线程的区别
	创建进程的消耗要远远大于线程

创建线程的两种方式

from threading import Thread
from multiprocessing import Process
import time


def task(name):
    print(f'{name} is running')
    time.sleep(0.1)
    print(f'name is over')


if __name__ == '__main__':
    start_time = time.time()
    p_list = []
    # for i in range(100):
    #     p = Process(target=task, args=(f'用户{i}',))
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:
    #     p.join()
    print(time.time() - start_time)  # 进程执行的时间1.2412874698638916
    t_list = []
    for i in range(100):
        t = Thread(target=task, args=('用户%s'%i,))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(time.time() - start_time)  # 线程执行的时间0.11986708641052246


"""
创建线程无需考虑反复执行的问题
"""
第二种方式：
class MyThread(Thread):
    def run(self):
        print('run is running')
        time.sleep(1)
        print('run is over')
obj = MyThread()
obj.start()
print('主进程')
"""
执行顺序
run is running、主进程、run is over
"""

线程的诸多特性

1.join方法
2.同进程内多个线程数据共享
3.current_thread()
4.active_count()

python多线程是否有用

需要分情况
	情况1
    	单个CPU
       多个CPU
   	情况2
    	IP密集型（代码有IO操作）
       计算密集型（代码没有IO）
1.单个CPU
	IO密集型
    	多进程
        申请额外的空间 消耗更多的资源
       多线程
    	  消耗资源相对较少，通过多道技术
     ps:多线程有优势
   计算密集型
   		多进程
    		申请额外的空间，消耗更多的资源（总耗时 + 申请空间+拷贝代码+切换）
        多线程
        	消耗资源相对较少，通过多道技术（总耗时+切换）
     ps:多线程有优势
2.多个CPU
	IO密集型
   		多进程
         总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
       多线程
    	  总耗时(单个进程的耗时+IO)
       ps:多线程有优势!!!
	计算密集型
    	多进程
       	  总耗时(单个进程的耗时)
    	多线程
          总耗时(多个进程的综合)
       ps:多进程完胜!!!        2.多个CPU
	IO密集型
   		多进程
         总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
       多线程
    	  总耗时(单个进程的耗时+IO)
       ps:多线程有优势!!!
	计算密集型
    	多进程
       	  总耗时(单个进程的耗时)
    	多线程
          总耗时(多个进程的综合)
       ps:多进程完胜!!!
        
        
from threading import Thread
from multiprocessing import Process
import os
import time


def work():  # 计算密集型
    res = 1
    for i in range(1, 10000):
        res *= i


if __name__ == '__main__':
    print(os.cpu_count())  # 查看当前计算机CPU的个数
    start_time = time.time()
    p_list = []
    for i in range(12):  # 一次性创建12个进程
        p = Process(target=work)
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()   # 让主进程等待全部子进程结束
    print('总耗时:%s' % (time.time() - start_time))
    t_list = []
    for i in range(12):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))
"""
计算密集型
    多进程：0.19
    多线程：0.43
"""

def work():
    time.sleep(2)   # 模拟纯IO操作


if __name__ == '__main__':
    start_time = time.time()
    t_list = []
    for i in range(100):
        t = Thread(target=work)
        t.start()
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))
    p_list = []
    for i in range(100):
        p = Process(target=work)
        p.start()
    for p in p_list:
        p.join()
    print('总耗时:%s' % (time.time() - start_time))

IO密集型
    多线程:0.00800013542175293
    多进程:0.7761733531951904
"""

原文地址：http://www.cnblogs.com/zhanghong1229/p/16913114.html