线程
线程是cpu执行调度的实体，是一个轻量级的“进程”。每个进程至少有一个线程。
线程与进程的区别:
同一个进程内的多个线程共享该进程内的地址资源
创建线程的开销要远小于创建进程的开销
2.1 开启线程的两种方式
#方式一 from threading import Thread import time def task(name): print('%s is running ' % name) time.sleep(2) print("%s is done" % name) if __name__ == '__main__': t = Thread(target=task, args=('子线程',)) t.start() print("主线程") # 方式二 from threading import Thread import time class Sayhi(Thread): def __init__(self, name): super().__init__() self.name = name def run(self): time.sleep(2) print('%s say hello' % self.name) if __name__ == '__main__': t = Sayhi('yk') t.start() print('主线程')
2.2 Thread对象的其他属性或方法
Thread实例对象的方法
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。threading模块提供的一些方法：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
from threading import Thread import threading def work(): import time time.sleep(3) print(threading.current_thread().getName()) if __name__ == '__main__': # 在主进程下开启线程 t = Thread(target=work) t.start() print(threading.current_thread().getName()) print(threading.current_thread()) # 主线程 print(threading.enumerate()) # 连同主线程在内有两个运行的线程 print(threading.active_count()) print('主线程/主进程') ''' MainThread <_MainThread(MainThread, started 22644)> [<_MainThread(MainThread, started 22644)>, <Thread(Thread-1, started 528)>] 2 主线程/主进程 Thread-1 '''
from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=Thread(target=sayhi,args=('yk',)) t.start() t.join() print('主线程') print(t.is_alive()) ''' yk say hello 主线程 False '''
2.3 守护线程
守护线程
无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁
需要强调的是：运行完毕并非终止运行
1、对主进程来说，运行完毕指的是主进程代码运行完毕
2、对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行
完毕，主线程才算运行完毕详细解释：
1、主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,
然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，2、主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。
因为主线程的结束意味着进程的结束，
进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。
from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' % name) if __name__ == '__main__': t = Thread(target=sayhi, args=('egon',)) t.setDaemon(True) # 必须在t.start()之前设置 t.start() print('主线程') print(t.is_alive()) # 走到这里，因为还有其它非守护线程没运行完毕，所以主线程其实还没退出，所以是True ''' 主线程 True '''
from threading import Thread import time def foo(): print(123) time.sleep(1) print("end123") def bar(): print(456) time.sleep(3) print("end456") if __name__ == '__main__': t1 = Thread(target=foo) t2 = Thread(target=bar) t1.daemon = True t1.start() t2.start() print("main-------") # time.sleep(3) print(t1.is_alive()) print(t2.is_alive()) ''' 123 456 main------- True True end123 end456 '''
2.4 GIL全局解释器锁
GIL本质就是一把互斥锁，既然是互斥锁，所有互斥锁的本质都一样，都是将并发运行变成串行，
以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。也就是同一时间只能由一个任务执行。
GIL与Lock
机智的同学可能会问到这个问题：Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock?
首先，我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据
然后，我们可以得出结论：保护不同的数据就应该加不同的锁。
最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），
后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock，
那线程用来干什么？
现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。
用c语言解决GIL的问题
loop.c # 下面是用C语言写的一个函数，函数名为DeadLoop void DeadLoop() { while(1) { ; } } 把一个ｃ语言文件编译成一个动态库的命令（linux平台下）: gcc xxx.c -shared -o libxxxx.so from ctypes import * from threading import Thread #加载动态库 lib = cdll.LoadLibrary("./libdead_loop.so") #创建一个子线程，让其执行ｃ语言编写的函数，此函数是一个死循环 t = Thread(target=lib.DeadLoop) t.start() #主线程 while True: pass
总结：
如果并发的多个任务是计算密集型：多进程效率高
如果并发的多个任务是IO密集型：多线程效率高应用：
多线程用于IO密集型，如socket，爬虫，web
多进程用于计算密集型，如金融分析
2.5 死锁与递归锁
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，产生了一个环路的状态。
若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁
from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print(' 33[41m%s 拿到A锁 33[0m' %self.name) mutexB.acquire() print(' 33[42m%s 拿到B锁 33[0m' %self.name) mutexB.release() mutexA.release() def func2(self): mutexB.acquire() print(' 33[43m%s 拿到B锁 33[0m' %self.name) time.sleep(2) mutexA.acquire() print(' 33[44m%s 拿到A锁 33[0m' %self.name) mutexA.release() mutexB.release() if __name__ == '__main__': for i in range(10): t=MyThread() t.start() ''' Thread-1 拿到A锁 Thread-1 拿到B锁 Thread-1 拿到B锁 Thread-2 拿到A锁 '''
递归锁
递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁，
二者的区别是：递归锁可以连续acquire多次，而互斥锁只能acquire一次
from threading import Thread,RLock import time mutexA=mutexB=RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程想获取锁都只能等待，等待该线程释放所有锁，即counter递减到 0为止 class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print(' 33[41m%s 拿到A锁 33[0m' %self.name) mutexB.acquire() print(' 33[42m%s 拿到B锁 33[0m' %self.name) mutexB.release() mutexA.release() def func2(self): mutexB.acquire() print(' 33[43m%s 拿到B锁 33[0m' %self.name) time.sleep(2) mutexA.acquire() print(' 33[44m%s 拿到A锁 33[0m' %self.name) mutexA.release() mutexB.release() if __name__ == '__main__': for i in range(3): t=MyThread() t.start() ''' Thread-1 拿到A锁 Thread-1 拿到B锁 Thread-1 拿到B锁 Thread-1 拿到A锁 Thread-2 拿到A锁 Thread-2 拿到B锁 Thread-2 拿到B锁 Thread-2 拿到A锁 Thread-3 拿到A锁 Thread-3 拿到B锁 Thread-3 拿到B锁 Thread-3 拿到A锁 '''
2.6 信号量，Event
Event
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。
如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。
如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行。
from threading import Thread, Event import time def student(name): print("%s正在上课" % name) event.wait() # 在这里阻塞，等待一个信号 print("%s 课间活动" % name) def teacher(): print("杨老师正在上课") time.sleep(7) event.set() # 发出一个信号 print("现在下课！") if __name__ == '__main__': event = Event() s1 = Thread(target=student, args=('dx',)) s2 = Thread(target=student, args=('gz',)) s3 = Thread(target=student, args=('yc',)) t1 = Thread(target=teacher, ) s1.start() s2.start() s3.start() t1.start() ''' dx正在上课 gz正在上课 yc正在上课 杨老师正在上课 现在下课！ dx 课间活动 gz 课间活动 yc 课间活动 '''
信号量
from threading import Thread, Semaphore, current_thread import random, time def task(): with sm: print("%s in " % current_thread().getName()) time.sleep(random.randint(1, 2)) if __name__ == '__main__': sm = Semaphore(3) for i in range(10): t = Thread(target=task) t.start()
2.7 定时器
from threading import Timer import random class Code(): def __init__(self): self.makeCode() def makeCode(self, interval=5): self.cache = self.code() print(self.cache) # interval秒后启动 self.makeCode self.t = Timer(interval, self.makeCode) self.t.start() # 随机验证码 def code(self, n=5): res = '' for i in range(n): s1 = str(random.randint(0, 9)) s2 = chr(random.randint(65, 90)) res += random.choice([s1, s2]) return res def check(self): while True: res = input("请输入验证码:").strip() if self.cache == res.upper(): print("输入码正确") # 如果正确，取消定时器事件 self.t.cancel() break obj = Code() obj.check() ''' 720EX 请输入验证码:720ex 输入码正确 '''
2.8 线程queue
import queue # q = queue.Queue(3) # q.put("1") # q.put("2") # q.put("3") # print(q.get()) # print(q.get()) # print(q.get()) # print(q.get()) # 超过个数会阻塞 # q = queue.LifoQueue(3) # 堆栈 # q.put("1") # q.put("2") # q.put("3") # # # print(q.get()) # print(q.get()) # print(q.get()) q = queue.PriorityQueue(3) # 优先级队列 q.put((10, "1")) q.put((5, "1")) q.put((40, "1")) print(q.get()) print(q.get()) print(q.get()) ''' (5, '1') (10, '1') (40, '1') '''
2.9 进程池和线程池
基本方法
1、submit(fn, *args, **kwargs)
异步提交任务2、map(func, *iterables, timeout=None, chunksize=1)
取代for循环submit的操作3、shutdown(wait=True)
相当于进程池的pool.close()+pool.join()操作
wait=True，等待池内所有任务执行完毕回收完资源后才继续
wait=False，立即返回，并不会等待池内的任务执行完毕
但不管wait参数为何值，整个程序都会等到所有任务执行完毕
submit和map必须在shutdown之前4、result(timeout=None)
取得结果5、add_done_callback(fn)
回调函数
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor import time, random, os def task(name): print("name:%s is running" % name) time.sleep(random.randint(1, 3)) if __name__ == '__main__': pool = ProcessPoolExecutor(2) # 进程池允许的个数 for i in range(4): pool.submit(task, 'yk%s' % i) print("主线程") ''' 主线程 name:yk0 is running name:yk1 is running name:yk2 is running name:yk3 is running ''' 线程池API调用方式一样。 ``` 回调函数 add_done_callback() ```
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor from multiprocessing import Pool import requests import json import os def get_page(url): print('<进程%s> get %s' % (os.getpid(), url)) respone = requests.get(url) if respone.status_code == 200: return {'url': url, 'text': respone.text} def parse_page(res): res = res.result() print('<进程%s> parse %s' % (os.getpid(), res['url'])) parse_res = 'url:<%s> size:[%s] ' % (res['url'], len(res['text'])) with open('db.txt', 'a') as f: f.write(parse_res) if __name__ == '__main__': urls = [ 'https://www.baidu.com', 'https://www.python.org', 'https://www.blogtreequan.com/', 'https://help.github.com/', 'http://www.sina.com.cn/' ] p = ProcessPoolExecutor(3) for url in urls: p.submit(get_page, url).add_done_callback(parse_page) # parse_page拿到的是一个future对象obj，需要用obj.result()拿到结果