python 进程和线程

进程和线程的理解：
计算机就像一个汽车厂，当有一个汽车来汽车厂的时候，就相当于我们的计算机打开了一个程序，汽车来到汽车厂之后，汽车厂首先是给这个汽车分配洗车位，如果是一辆小汽车，可能只需要分配一个汽车位，如果是一辆客车，就需要分配两个汽车位。这就好比是我们打开一个程序之后，计算机要给这个程序的进程分配各种系统资源，比如一定的内存。当我们的汽车分配好汽车位之后，就会有一个汽车工开始洗这辆车。汽车就好比计算机里的进程，而这个洗车工就相当于线程。但来汽车厂的汽车，除了洗车之外，有些汽车还需要给汽车检修一下，这样的话这里的检修工又相当于一个线程。每一个程序至少有一个进程，每一进程至少有一个线程。

进程与线程

进程就是一个程序在一个数据集上的一次动态执行过程。 进程一般由程序、数据集、进程控制块三部分组成。

线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

进程

需要导入的模块

from multiprocessing import Process 

单一进程

import time
from multiprocessing import Process

def test(id):       ##进程要执行的函数
    time.sleep(1)      #进程挂起时间，正常程序不需要     
    print("进程%d结束！"%(id))
    
if __name__ == '__main__':  #主函数
    t1 = time.time()
    p = Process(target=test, args=(1,)) #进程创建，target=要执行的函数，args=参数（以元组形式传递）
    p.start()       #开始进程
    p.join()        #等所以子进程执行完后返回主进程
    t2 = time.time()
    print(t2-t1)

多进程（模拟进程池）

import time 
from multiprocessing import Process     ##模块导入
def test(id):       ##进程要执行的函数
    time.sleep(1)      #进程挂起时间      
    print("进程%d结束！"%(id))
if __name__ == '__main__':
    #freeze_support()
    t1=time.time()
    pool=[]
    for i in range(1,10):       ##要执行的进程的个数
        p=Process(target=test, args=(i,))       ###主进程的创建
        p.start()
        pool.append(p)      ##模拟一个进程池
    for p in pool:      
        p.join()        ##等所有子进程都返回到主进程
    t2=time.time()
    print(t2-t1)

进程池

from multiprocessing import Pool
import time

def func(id):
    time.sleep(1)
    print(f'进程{id}')

if __name__=="__main__":    
    start=time.time()
    p=Pool(10)      ##进程池
    for i in range(1,11):
        p.apply_async(func,args=(i,)) ##像进程池添加进程
    p.close()   ##关闭进程池
    p.join()     ###统一回到主进程
    end=time.time()
    print(end-start)
    print("OK!")

进程池的最佳执行个数。

线程

单一线程

import time 
from threading import Thread

def test(id):       ##执行函数
    time.sleep(1)            
    print("线程%d结束！"%(id))
if __name__ == '__main__':

    ts=time.time()       
    t=Thread(target=test, args=(1,))    ##线程的创建
    t.start()       ##线程的开始   
    t.join()        ##等所有子线程都都执行完后才回收
    te=time.time()
    print(te-ts)

多线程（模拟线程池）

import time 
from threading import Thread

def test(id):       ##执行函数
    time.sleep(1)            
    print("线程%d结束！"%(id))
if __name__ == '__main__':
    #freeze_support()
    ts=time.time()
    threads=[]      ##模拟线程池
    for i in range(1,10):
        t=Thread(target=test, args=(i,))    ##主线程的创建
        t.start()       ##线程的开始
        threads.append(t)
    for t in threads:
        t.join()        ##等所有子线程都都执行完后才回收
    te=time.time()
    print(te-ts)

线程池

import time
import threadpool  
def sayhello(str):          ##执行函数
    print ("Hello ",str)
    time.sleep(2)

name_list =['xiaozi','aa','bb','cc']
start_time = time.time()
pool = threadpool.ThreadPool(10)        ##线程池中的线程的个数
        ##调用makeRequests创建了要开启多线程的函数，以及函数相关参数和回调函数
        ##其中回调函数可以不写，default是无，也就是说makeRequests只需要2个参数就可以运行；
        
requests = threadpool.makeRequests(sayhello, name_list) 

[pool.putRequest(req) for req in requests] 
""" 
是将所有要运行多线程的请求扔进线程池，[pool.putRequest(req) for req in requests]等同于

　　for req in requests:  

　　　　 pool.putRequest(req) 
"""
pool.wait() 
print ('%d second'% (time.time()-start_time))