9-3 线程，线程池，守护线程，锁,协程

一 线程

# 什么是进程 ：是计算机资源分配的最小单位
# 什么是线程
# 线程和进程的关系 ：
    # 每一个进程中都至少有一个线程
#开启100个线程

import os
import time
from threading import Thread
n=100
def func(i):
    global n
    time.sleep(1)
    n-=1
    print(os.getpid(),'thread%s'%i)
l=[]
for i in range(100):
    t=Thread(target=func,args=(i,))
    t.start()
    l.append(t)
for i in l:
    i.join()
print(n)


n的结果是0

总结：

 #每个进程里至少有一个主线程负责执行代码
# 在主线程中可以再开启一个新的线程
# 在同一个进程中就有两个线程同时在工作了
# 线程才是CPU调度的最小单位
# 多个线程之间的数据时共享的

二 守护线程

# 主线程结束了之后守护线程也同时结束
# 守护线程会等待主线程完全结束之后才结束

from threading import Thread
import time
def foo():
    while True:
        print(123)
        time.sleep(1)
def bar():
    print(456)
    time.sleep(3)
    print('end456')
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True #foo是守护线程
t1.start()
t2.start()
print("main----") #主线程结束的地方

打印结果：
123
456
main----
123
123
end456

 三 锁（Lock）

1普通锁 lock

# 当你的程序中出现了取值计算再赋值的操作 数据不安全 —— 加锁

from threading import Thread,Lock
import time
def work():
    global n

    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock = Lock()
    n=100
    l=[]
    for i in range(10):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for i in l:
        i.join()
    print(n)

最后n的值为90

2 递归锁（Rlock）(很少用)

from threading import RLock

lock = RLock()
lock.acquire()
lock.acquire()
print(123)
lock.release()
print(456)
lock.release()

总结：

# 普通的锁 在同一个线程中 只能acquire一次
# 所以当acquire两次的时候就容易出现死锁现象
# 出现了死锁现象可以使用递归锁去解决问题
# 但是本质上死锁的出现是因为逻辑的错误
# 因此我们更应该把注意力集中在解决逻辑错误
# 而不要在出现错误的时候直接用递归锁规避

递归锁并没有本质上解决死锁的问题

 

四 线程池（ThreadPoolExecutor）

1

import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(num):
    print(num)
    time.sleep(1)
    print(num)
if __name__ == '__main__':
    t=ThreadPoolExecutor(20) #20个线程，每次处理20个
    for i in range(50):
        t.submit(func,i) #异步提交命令
    t.shutdown()#同join整个线程池
    print('done')

2 回调函数（callback）

# import time
# import random
# from concurrent.futures import ThreadPoolExecutor
# from threading import current_thread
# urls=[
#         'https://www.baidu.com',
#         'https://www.python.org',
#         'https://www.openstack.org',
#         'https://help.github.com/',
#         'http://www.sina.com.cn/'
#         'http://www.cnblogs.com/'
#         'http://www.sogou.com/'
#         'http://www.sohu.com/'
#     ]
#
# def analies(content):
#     print('分析网页',current_thread())
#     print(content.result())
#
#
# def get_url(url):
#     print('爬取网页',current_thread())
#     time.sleep(random.uniform(1,3))
#     # analies(url*10)
#     return url*10
#
# t = ThreadPoolExecutor(3)
# print('主线程',current_thread())
# for url in urls:
#     t.submit(get_url,url).add_done_callback(analies) #

#回调函数当执行了get_url之后，得到了一个url*10 ,然后在立即执行analies函数，并传给content参数

# concurrent.futures里面的 callback是由子线程做的

 五协程（gevent）
需要手动安装，第三方模块
安装 ：pip3 install gevent

协程 把一个线程拆分成几个

# 协程 是程序级别调度

# 减轻了操作系统的负担、增强了用户对程序的可控性

特点是：只要遇到阻塞就会执行别的任务。例如：

from gevent import monkey;monkey.patch_all()
import gevent
import time
def eat(name):
    print('%s eat 1' %name)
    time.sleep(2)
    print('%s eat 2' %name)

def play(name):
    print('%s play 1' %name)
    time.sleep(1)
    print('%s play 2' %name)


g1=gevent.spawn(eat,'egon')
g2=gevent.spawn(play,'alex')
g1.join()
g2.join()
# gevent.joinall([g1,g2])#第二种写法
print('主')

执行结果是：

egon eat 1
alex play 1
alex play 2
egon eat 2
主

例2：利用协程批量访问url

from gevent import monkey;monkey.patch_all() #这个是必须加的否则gevent不识别time
import gevent
import requests
import time

def get_page(url):
    print('GET: %s' %url)
    response=requests.get(url)
    if response.status_code == 200:
        print('%d bytes received from %s' %(len(response.text),url))


start_time=time.time()
gevent.joinall([
    gevent.spawn(get_page,'https://www.python.org/'),
    gevent.spawn(get_page,'https://www.yahoo.com/'),
    gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))