本文共 4686 字，大约阅读时间需要 15 分钟。

目录

线程

在一个进程内部要同时干多件事，就需要同时运行多个‘子任务’，我们把这些子任务称为线程线程通常叫做轻型的线程。线程是共享内存空间的并发执行的多任务，每一个线程都共享一个进程的资源线程是最小的执行单元，而进程至少要有一个线程。如何调度进程和线程，完全由操作系统决定，程序不能决定什么时候执行，执行多长时间模块1._thread模块  低级模块2.threading模块  高级模块，对_thread进行了封装

例子：

import threadingimport timedef 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 threadingimport timen = 100def 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 threadingimport timenum = 0#创建一个全局的threadLocal对象#每个线程有独立的存储空间#每个线程对threadLocal对象都可以读写，但是互不影响local = threading.local()list = [num,num]def run(x,n):    x = x + n    x = x - ndef 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,timedef 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 evente = 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 dataa = A()#启动aprint(a.send(None))print(a.send('a'))

 运行结果：

一起学习，一起进步 -.- ，如有错误，可以发评论

转载地址：https://kongchengji.blog.csdn.net/article/details/95883926 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！