线程、进程、queue、multiprocessing

线程和进程概述：

　　主进程、子进程 　 

　　主线程、子线程

进程：

　　优点：同时利用多个CPU，能够同时进行多个操作。

　　缺点：耗费资源（重新开辟内存空间）

线程：

　　优点：共享内存，IO操作时候，创造并发操作

　　缺点：抢占资源

进程不是越多越好，CPU个数=进程个数

线程不是越多越好，具体案例具体分析，请求上下文需要时间。

进程和线程目的：提高执行效率。

IO操作利用CPU

IO密集型（不用CPU）

　　多线程

计算密集型（用CPU）

　　多进程

上图蓝色框：GIL 全局解释器锁

import  threading
import  time

globals_num = 0
lock = threading.RLock()

def Func():
    lock.acquire() #获得锁
    global  globals_num
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release() #释放锁

for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

threading.Event

 

import  threading
def  do(event):
    print("start")
    event.wait()
    print("execute")

event_obj  = threading.Event()
for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()

event_obj.clear()
inp = input("input:")
if inp  == 'true':
    event_obj.set()

 

 

queue模块

Queue 就是队列，踏实线程安全的

multiprocessing

from  multiprocessing import  Process
def f(name):
    print('hello',name)


if __name__ == '__main__':
    p = Process(target=f, args=('bob',)) #把f函数放进target。args就是f函数的参数。
    p.start()
    p.join()

进程间的数据共享

from  multiprocessing import  Process,Value,Array
def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]


if __name__ == '__main__':
    num  = Value('d', 0.0)
    arr = Array ('i', range(10))

    p = Process(target=f, args=(num, arr)) #创建进程。把f函数放进target。args就是f函数的参数。
    p.start()
    p.join()

    print(num.value)
    print(arr[:])

from  multiprocessing import  Process,Value,Array
def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]


if __name__ == '__main__':
    num  = Value('d', 0.0)
    arr = Array ('i', range(10))

    p = Process(target=f, args=(num, arr)) #创建进程。把f函数放进target。args就是f函数的参数。
    a = Process(target=f, args=(num, arr))
    p.start()
    a.start()
    p.join()
    a.join()

    print(num.value)
    print(arr[:])

进程间的数据共享2， 

from  multiprocessing import  Process,Manager
def f(d, l):
   d[1] = 1
   d['2'] = 2
   d[0.25] = None
   l.reverse()


if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()
        l = manager.list()

        p = Process(target=f, args=(d, l))
        p.start()
        p.join()

        print(d)
        print(l)

进程池

 

 

from  multiprocessing import  Pool
import time
def myFun(i):
    time.sleep(2)
    return i + 100

def end_call(arg):
    print("end_call",arg)

if __name__ == '__main__':

    p = Pool(5)
    for i in range(10):
        p.apply_async(func=myFun, args=(i,), callback=end_call)

    print('end')
    p.close()
    p.join()

线程知识回顾

 

线程创建：

import  time
import  threading
def f0():
    pass

def f1(a1, a2):
    time.sleep(10)
    print(a1, a2)
    f0()

t =  threading.Thread(target=f1, args=(123, 111)) #创建进程
t.setDaemon(True) #设置主线程是否等待 子线程执行完。默认False 等待。 True 不等待。
t.start()

t =  threading.Thread(target=f1, args=(123, 111))
t.setDaemon(True)
t.start()

t =  threading.Thread(target=f1, args=(123, 111))
t.setDaemon(True)
t.start()

t.setDaemon(True/False) 是否等待子线程

t.join(2) #主线程等待子线程执行完后，再往下执行，可以有参数t.join(2) 2代表最多等待2秒。

import  time
import  threading
def f0():
    pass

def f1(a1, a2):
    time.sleep(10)

    f0()

t =  threading.Thread(target=f1, args=(123, 111))
print('111')
t.start()
t.join(2) #等待线程执行完后，再往下执行，可以有参数t.join(2) 2代表最多等待2秒。
print('222')
t =  threading.Thread(target=f1, args=(123, 111))
t.start()

 

 

 

 进程

　　1、创建进程 

import  multiprocessing
import  time

def f1(a1):
    time.sleep(2)
    print(a1)

if __name__ == '__main__':

    t = multiprocessing.Process(target=f1, args=(11,)) #创建进程
    t.daemon = True  # 值为False时，不等待，直接往下执行。
    t.start()
    t2 = multiprocessing.Process(target=f1, args=(11,))  # 创建进程
    # t2.daemon = True
    t2.start()
    print('end')

进程之间内存不能共享

from multiprocessing import Process

li = []
def foo(i):
    li.append(i)
    print('say hi',li)
if __name__ == '__main__':
    for i in range(10):
        p = Process(target=foo, args=(i,))
        p.start()

 

进程之间内存需要共享可以有方法做到
方法一： Array
方法二：manager

from multiprocessing import Process,Manager

def Foo(i, dic):
    dic[i] = 100+i
    print(len(dic))
    for k, v in dic.items():
        print(k, v)

if __name__ == '__main__':
    manage = Manager()
    # dic = manage.dict() #特殊字典类型，可在进程之间共享内存数据。
    dic = {}
    for i in range(2):
        p = Process(target=Foo, args=(i ,dic))
        p.start()
        p.join()

 

 

 

 

 

from multiprocessing import  Pool
import  time
def f1(a):
    time.sleep(1)
    print(a)
    return  100
def f2(arg):
    print(arg)

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        # pool.apply(func=f1,args=(i,) ) #每个任务排队执行
        pool.apply_async(func=f1, args=(i,), callback=f2) #任务并发执行，callback=f2 回调函数 ，每个任务执行完都会返回参数。
        print("1111111")
    pool.close()
    pool.join()

Low版线程池

 

import queue
import  threading
import time
class ThreadPool(object):

    def __init__(self, max_num=20): #
        self.queue = queue.Queue(max_num) #创建最多20队列
        for i in range(max_num):
            self.queue.put(threading.Thread) #threading.Thread 函数

    def get_thread(self):
        return self.queue.get()

    def add_thread(self):
        self.queue.put(threading.Thread)

def func(pool,a1):
    time.sleep(1)
    print(a1)
    pool.add_thread()
p = ThreadPool(10)
for i in range(100):
    thread = p.get_thread()
    t = thread(target=func, args=(p, i))
    t.start()

 绝版线程池

1、队列，放任务

2、线程一次一次的取任务

个人对绝版线程池的理解：

　　　　1、创建队列

　　　　2、创建任务，把任务放进队列里 。

　　　　3、线程把任务一个一个的取出来执行。