目录
线程
在一个进程内部要同时干多件事，就需要同时运行多个‘子任务’，我们把这些子任务称为线程
线程通常叫做轻型的线程。线程是共享内存空间的并发执行的多任务，每一个线程都共享一个进程的资源
线程是最小的执行单元，而进程至少要有一个线程。
如何调度进程和线程，完全由操作系统决定，程序不能决定什么时候执行，执行多长时间
模块
1._thread模块 低级模块
2.threading模块 高级模块，对_thread进行了封装
例子：
import threading
import time
def run():
print('子线程%s启动' % (threading.current_thread().name))
#实现线程功能
print('打印')
time.sleep(1)
print('子线程%s结束' % (threading.current_thread().name))
if __name__=='__main__':
#任何进程默认就会启动一个线程，称为主线程，主线程可以启动新的子线程
#current_thread()：返回当前线程的实例
print('主线程%s启动' %(threading.current_thread().name))
#创建子线程
t = threading.Thread(target=run,name='runthread')
t.start()
#等待线程结束
t.join()
print('主线程%s结束' % (threading.current_thread().name))
运行结果：
多进程和多线程最大的不同在于：多进程中，同一个变量，各自有一份拷贝在每个进程中，互不影响。多线程中，所有变量都由所有线程共享。所以任何一个变量都可以被任意一个线程修改。因此线程之间最大的危险在于同时修改一个变量容易把内容改乱了。
例子：
import threading
import time
n = 100
def run():
global n
n = n + 20
print('run:',n)
def fun():
global n
n = n /10
print('fun:',n)
if __name__=='__main__':
#创建子线程
t = threading.Thread(target=run,name='runthread')
t.start()
t.join()
k = threading.Thread(target=fun, name='funthread')
k.start()
运行结果：
线程锁解决数据混乱
两个线程同时工作，一个存钱，一个取钱
可以给线程设置一个局部变量，使用threadLocal对象
例子：
import threading
import time
num = 0
#创建一个全局的threadLocal对象
#每个线程有独立的存储空间
#每个线程对threadLocal对象都可以读写，但是互不影响
local = threading.local()
list = [num,num]
def run(x,n):
x = x + n
x = x - n
def fun(n):
#每个线程都有一个local.x，就是线程的局部变量
local.x = num
for i in range(100000):
run(local.x,n)
print('%s--%d' %(threading.current_thread().name,local.x))
if __name__=='__main__':
#创建子线程
t = threading.Thread(target=fun,args=(6,))
t2 = threading.Thread(target=fun, args=(9,))
t.start()
t2.start()
t.join()
t2.join()
print('num = ',num)
运行结果：
线程通信
线程阻塞和触发事件
例子：如果不使用e.set()去触发事件，run()方法将不会被执行
import threading,time
def fun():
#事件对象
event = threading.Event()
def run():
for i in range(5):
#阻塞，等待事件的触发
event.wait()
#重置
event.clear()
print('what happen ...%d' % i)
t = threading.Thread(target=run).start()
return event
e = fun()
#触发事件
for i in range(5):
e.set()
time.sleep(1)
运行结果：
生产者与消费者
4个生产者在生产数据 3个消费者将生产的数据从队列中取出
import threading,time,queue,random
#生产者
def product(id,q):
while True:
num = random.randint(0,10000)
q.put(num)
print('生产者%d生产了%d数据放入了队列' % (id,num))
time.sleep(3)
#任务完成
q.task_done()
#消费者
def customer(id,q):
while True:
item = q.get()
if item is None:
break
print('消费者%d消费了%d数据' % (id,item))
time.sleep(2)
# 任务完成
q.task_done()
if __name__=='__main__':
#消息队列
q = queue.Queue()
#启动生产者 4
for i in range(4):
threading.Thread(target=product,args=(i,q)).start()
#启动消费者 3
for i in range(3):
threading.Thread(target=customer,args=(i,q)).start()
运行结果：
线程调度
调度两个线程之间的执行顺序
import threading,time
#线程条件变量
cond = threading.Condition()
def run1():
with cond:
for i in range(0,10,2):
print(threading.current_thread().name,i)
time.sleep(1)
#运行一次然后等待run2信息
cond.wait()
cond.notify()
def run2():
with cond:
for i in range(1,10,2):
print(threading.current_thread().name,i)
time.sleep(1)
#给run1发送信息
cond.notify()
#等待
cond.wait()
threading.Thread(target=run1).start()
threading.Thread(target=run2).start()
运行结果：
计算密集型和IO密集型
计算密集型
要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，所以，要最高效地利用CPU,计算密集型任务同时进行的数量应当等于CPU的核心数
IO密集型
涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分 时间都在等待IO操作完成(因为IO的速度远远低于CPU和内存的速度)。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是I0密集型任务，比如Web应用
协程
子程序/函数：在所有语音中都是层级调用，比如A调用B，在B执行的过程中又可以调用C，C执行完毕返回，B执行完毕返回，最后是A执行完毕一个线程就是执行一个子程序，子程序调用总是一个入口，一次返回，调用的顺序是明确的
协程概述：看上去也是子程序，但是在执行过程中，在子程序的内部可以中断，然后转而去执行别的子程序。那么不是函数调用，有点类似与CPU中断
与线程相比，协程的执行效率极高。因为只有一个线程，不存在多个变量同时写，不存在变量冲突，在协程中资源共享不加锁，只需要判断状态
例子：子程序调用
def C():
print('C---START')
print('C---END')
def B():
print('B---START')
C()
print('B---END')
def A():
print('A---START')
B()
print('A---END')
A()
运行结果：
python对协程的支持是通过generator实现的
例子：协程
def A():
print(1)
yield 10
print(2)
yield 20
print(3)
yield 30
#协程的最简单风格，控制函数的阶段执行，节约线程或者进程的切换
#返回值是一个生成器
a = A()
print(type(a))
print(next(a))
print(next(a))
print(next(a))
运行结果：
例子：
def A():
#空变量，存储的作用data始终为空
data = ''
r = yield data
print(1,r,data)
r = yield data
print(2,r,data)
r = yield data
print(3,r,data)
r = yield data
a = A()
#启动a
print(a.send(None))
print(a.send('a'))
运行结果：
一起学习，一起进步 -.- ，如有错误，可以发评论
