Python_oldboy_自动化运维之路_线程，进程，协程

Posted 2020-09-06

本节内容：

1. 线程
2. 进程
3. 协程
4. IO多路复用
5. 自定义异步非阻塞的框架

线程和进程的介绍：

举个例子，拿甄嬛传举列线程和进程的关系：

总结：
1.工作最小单元是线程，进程说白了就是提供资源的

2.一个应用程序至少有一个进程，一个进程里至少有一个线程

3.应用场景：io密集型适合用多线程，计算密集型(cpu)适合用多进程

4.GIL：全局解释器锁，作用:保证同一个进程中只能有一个线程同时被调用

5.python的一个诟病：前提是被cpu调度,因为有GIL，一个应用只有一个进程，纵容有多个线程，也体现不出多核的优势，除非有多个进程，好处是降低的python开发者的难度。

1.线程

Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元，开线程的主要的作用是可以帮我们同时做某些事情。

1.线程的基本使用

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
import threading
import time

def task(arg):                                      #隔1s后执行这三十个线程，是并发的，同时工作
    time.sleep(1)
    print(‘aaaaaaa‘,arg)


for i in range(30):                                 #这个是创建出30个线程来
    t = threading.Thread(target=task,args=[i,])
#    t.setDaemon(True)     #主程序结束，不等待子线程
#    t.setDaemon(False)   #默认

    t.start()

#    t.join()    #等一个线程执行完在执行下一个线程
#    t.join(1)  #等待最大时间，最多等1秒

print(‘end‘)    #这个就相当于主线程

线程

#end是主线程，等主线程创建好后会隔1s并发执行30个函数
end
aaaaaaa 0
aaaaaaa 1
aaaaaaa 2
aaaaaaa 4
aaaaaaa 5
aaaaaaa 3
aaaaaaa 6
aaaaaaa 7
aaaaaaa 9
aaaaaaa 8
aaaaaaa 11
aaaaaaa 10
aaaaaaa 13
aaaaaaa 12
aaaaaaa 14
aaaaaaa 17
aaaaaaa 15
aaaaaaa 16
aaaaaaa 19
aaaaaaa 18
aaaaaaa 20
aaaaaaa 21
aaaaaaa 22
aaaaaaa 23
aaaaaaa 25
aaaaaaa 26
aaaaaaa 24
aaaaaaa 27
aaaaaaa 28
aaaaaaa 29

输出

2.线程任务被调用过程

#线程执行的过程，自定义线程，我们的函数是被run方法调用的
import threading
import time

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

    def run(self):
        self.func()
        print(‘-------首先执行的是run方法-----‘)

def task():
    print(‘task函数。。。。‘)


obj=MyThread(func=task)
obj.start()

线程

task函数。。。。
-------首先执行的是run方法-----

输出

3.线程锁，只能有一个人使用锁

#用处：这样的话变量v就是来一个减一个，不会出现假如其中有线程没有执行完，在去减就会出错

import threading
import time

#创建锁
lock = threading.Lock()
#lock = threading.RLock()   #使用这种方法可以锁多次，但是解锁也要解锁多次，带递归的锁

v=10

def task(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=task,args=(i,))  #元组的方式最好加逗号，（后续）怕误以为是个函数
    t.start()

线程锁

9
8
7
6
5
4
3
2
1
0

输出

4.线程锁，同时多个人使用锁

import threading
import time

#创建锁
lock = threading.BoundedSemaphore(3)      #同时锁三个线程

v=10

def task(arg):

    lock.acquire()

    time.sleep(1)                        #当进来锁后等1秒，这时显示打印会三条三条的显示。
    global v
    v -= 1
    print(v)

    lock.release()


for i in range(10):
    t = threading.Thread(target=task,args=(i,))  #元组的方式最好加逗号，（后续）怕误以为是个函数
    t.start()

线程锁

#三个三个显示，等1秒
9
8
7
6
5
4
3
2
1
0

输出

5.线程锁，事件锁的应用

#3.事件锁,当触发某个条件，我生成的子线程才工作
import threading
import time

#创建锁
lock = threading.Event()

def task(arg):

    time.sleep(1)
    #锁住所有的线程
    lock.wait()
    print(arg)

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

while True:
    value = input(‘>>‘)
    if value == ‘1‘:
        lock.set()
#        lock.clear()   默认

事件锁

>>1
>>0
2
4
6
8
1
3
5
7
9

输出

6.线程锁，条件condition用法

#4.条件，Condition的用法,输入几就释放几个线程
import threading
import time

#创建锁
lock = threading.Condition()

def task(arg):

    time.sleep(1)
    #锁住所有的线程
    lock.acquire()
    lock.wait()
    print(‘线程‘,arg)
    lock.release()

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

while True:
    value = input(‘>>‘)
    lock.acquire()
    lock.notify(int(value))
    lock.release()

线程锁

C:\\Python35\\python3.exe D:/pycharm/s16/day9/2.锁.py
>>2
>>线程 0
线程 2
3
>>线程 1
线程 4
线程 3

输出