python之进程，线程，和协程

线程进程介绍

　　1. 工作最小单元是线程 

　　2. 应用程序 -> 至少有一个进程 -> 至少有一个线程

　　3. 应用场景：
　　　　IO密集型：线程
　　　　计算密集型：进程
　　4. GIL，全局解释器锁。
　　　　- 保证同一个进程中只有一个线程同时被调度

线程进程的区别

　　1.进程 内存独立，线程共享同一进程的内存
　　2.进程是资源的集合， 线程是执行单位
　　3. 进程之间不能直接互相访问，线程可以互相通信
　　4. 创建新进程非常消耗系统资源， 线程非常轻量，只保存线程需要运行时的必要数据，如上下文，程序堆栈
　　5. 同一进程里的线程可以互相控制，父进程之可以控制子进程

CPU是如何处理线程的

　　当某个程序下，所有开启的线程准备就绪，此时CPU就会在这些线程之间不停的切换处理每个线程的逻辑，之后返回结果，对于人的肉眼而言，就是并发的效果

python的多进程，多线程分析

　　假如系统有两个核心，此时呢有一个应用进程，里面开启了三个线程，每个进程中有一个主线程和两个子线程，CPU在处理线程的时候会随机调用，所以单个进程中
的不同的线程，有可能会被两个核心在同一时刻处理，从而实现利用多核优势并发，但是在python中，因为GIL（全局解释器锁）的存在，同一时刻每个进程中只能有一
个线程被处理。假设此时有一个进程，这种情况下python就不能利用多核的优势，因为只允许一个线程被处理对不对。另一个核心就浪费了呀！所以对于python而言，
做IO密集型任务的时候，才适合用多线程，因为不依赖CPU，而对于计算密集型任务，就使用多进程。

 　　建立http请求属于IO请求

python线程

创建　　　　　　

　　我们来创建一个线程玩玩，python中线程模块为threading　　 　　　　　　　　　　　

#_*_coding:utf-8_*_
__author__='wuzhihu'

import threading   导入线程模块

import time

def func(arg):       在这里我们首先创建一个函数来作为我们的任务
    time.sleep(1)
    print(arg)

for i in range(8):      利用for循环来同时开启多个线程
    t=threading.Thread(target=func,args=[i,])    创建一个线程
    t.start()   启动线程，告诉CPU准备就绪，来调用我把

print('end')   主线程执行一个打印任务

　　然后执行看返回结果，可以看到主线程先走到末尾了，而且各个线程的完结也都不一样，这也证实了，CPU是随机处理各个线程的，线程在启动了之后就会等在那里

"C:\Program Files\Python35\python.exe" F:/oldboy/day9/线程.py
end
4
3
2
5
1
0
6
7

指定主线程是否等待子线程　　

　　我们有时候呢可能会需要说，主线程结束的时候所有子线程也终止，我们来看看怎么做，如下添加一行，注意：必须加到start之前

#_*_coding:utf-8_*_
__author__='wuzhihu'

import threading

import time

def func(arg):
    time.sleep(1)
    print(arg)

for i in range(8):
    t=threading.Thread(target=func,args=[i,])
    t.setDaemon(True)
    t.start()

print('end')

　　执行结果

"C:\Program Files\Python35\python.exe" F:/oldboy/day9/线程.py
end

　　所以呢，这里如果不指定setDaemon为True的话，他默认为False

设定下个线程执行时等待上个线程的时间

 1 #_*_coding:utf-8_*_
 2 __author__='wuzhihu'
 3 
 4 import threading
 5 
 6 import time
 7 
 8 def func(arg):
 9     time.sleep(3)
10     print(arg)
11 
12 for i in range(8):
13     t=threading.Thread(target=func,args=[i,])
14     t.setDaemon(True)
15     t.start()
16     t.join(1)   指定等待的时间，默认为一直等待，知道上个线程执行完成，在执行下个线程17 
18 print('end')

线程里面的函数是如何调用的

　　可以看出来，是通过threading这个类中的run方法调用的

class Mythread(threading.Thread):
    def __init__(self,func,*args,**kwargs):
        super(Mythread,self).__init__(*args,**kwargs)
        self.func=func

    def run(self):
        self.func('hahaha')

def func(arg):
    time.sleep(1)
    print(arg)
    
obj=Mythread(func=func)
obj.start()

运行结果
"C:\Program Files\Python35\python.exe" F:/oldboy/day9/线程.py
hahaha

线程锁　　　　

　　有时候呢，我们会遇到某些操作不允许并发的情况，这时候就需要用到锁

允许一个线程进出

import threading
import time


v=10
# lock=threading.Lock()  #创建一把锁
lock=threading.RLock()  ##可以递归解锁
def func(arg):
    time.sleep(2)
    lock.acquire()  #锁住，从此处开始只允许进入一个线程
    lock.acquire()  ##双重锁
    global v
    v-=1
    print(v)
    lock.release()  #解锁
    lock.release()   #上几把锁，就解几把



for i in range(10):
    t=threading.Thread(target=func,args=[i,])
    t.start()
print('end')

运行结果：

"C:\Program Files\Python35\python.exe" F:/oldboy/day9/线程锁.py
end
9
8
7
6
5
4
3
2
1
0 

多个人同时使用锁　　

　　只需将上面的创建锁换成下面的方式即可，

lock=threading.BoundedSemaphore(3)   3表示允许三个线程同时进去

事件锁　　

import threading
import time


lock=threading.Event()    创建事件锁

def func(arg):

    time.sleep(2)
    lock.wait()      所有线程都在这里被锁住
    print(arg)

for i in range(10):
    t = threading.Thread(target=func, args=[i, ])
    t.start()

while True:
    value=input('>>')
    if value== '1':
        lock.set()     解锁

想释放多少进程就释放多少　　

import threading
import time

lock=threading.Condition()   ##创建自由锁

def func(arg):

    time.sleep(2)
    lock.acquire()
    lock.wait()
    print(arg)
    lock.release()

for i in range(10):
    t = threading.Thread(target=func, args=[i, ])
    t.start()

while True:
    value=input('>>')
    lock.acquire()
    lock.notify(int(value))   ##根据输入多少来释放相应的线程个数
    lock.release()

连接池　　

　　预留固定的线程等待连接

from concurrent.futures import ThreadPoolExecutor
import time
import requests

def tak(url):
    time.sleep(2)
    response=requests.get(url)
    print('返回结果',url,len(response.content))

pool=ThreadPoolExecutor(2)   建立一个线程池，预留两个线程
url_list=[
    'http://www.baidu.com',
    'http://hao123.com',
    'http://www.powercdn.com',
]

for url in url_list:
    print('开始请求',url)
    pool.submit(tak,url)   调用池子

回调函数　　

from concurrent.futures  import ThreadPoolExecutor

import time
import requests

pool=ThreadPoolExecutor(3)

def download(url):
    res=requests.get(url)
    return res        返回结果

def txt(future):
    download_res = future.result()    
    print('处理中',download_res.url,download_res.status_code)


url_list=[
    'http://www.baidu.com',
    'http://hao123.com',
    'http://www.powercdn.com',
]
for url in url_list:
    print('开始请求',url)
    future=pool.submit(download,url)    拿到download处理返回结果

    future.add_done_callback(txt)   调用txt函数处理download拿回来的数据

基于线程池的分布执行方式扩展　　

from concurrent.futures import ThreadPoolExecutor

import requests

def download(url):
    res=requests.get(url)
    return res

def run(url_list):
    pool=ThreadPoolExecutor(2)
    for item in url_list:
        url=item['url']
        call=item['call']
        future=pool.submit(download,url)
        future.add_done_callback(call)

import 基于线程池的分布执行方式扩展

def f1(future):
    res=future.result()
    print(res.text)
def f2(future):
    pass

url_list=[
    {'url':'http://www.baidu.com','call':f1},
    {'url':'http://hao123.com','call':f2}



]

基于线程池的分布执行方式扩展.run(url_list)

Timer　

　　定时器，规定时间以后执行某个操作

#_*_conding:utf-8_*_
__author__='wuzhihu'

from  threading import Timer

def hello():
    print('hello world')

t=Timer(2,hello)  ##设定为两秒以后执行hello函数
t.start()

python进程　

创建   　

from multiprocessing import Process   导入模块

import threading
import time

def hello(i):
    print('say hi',i)

if __name__=='__main__':       window下执行进程必须这样做，不然会报错呦

    for i in range(20):
        p=Process(target=hello,args=(i,))
        p.start()

python协程　　

　　协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

　　协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；