【并发编程】多线程

目录

一、什么是线程

二、开启线程的两种方式

三、多线程与多进程的区别

四、守护线程

五、GIL全局解释器锁

六、死锁和递归锁

七、信号量、Event、定时器

八、线程queue

九、进程池和线程池

---

一、什么是线程

1.1 概念

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。

1.2 进程和线程的区别

1、一个程序至少有一个进程，一个进程至少有一个线程。(进程可以理解成线程的容器)

2、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

3、线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

4、进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

 

二、开启线程的两种方式

2.1 threading模块介绍

threading模块的接口与multiprocess模块很相像。二者在使用层面，有很大的相似性，因而不再详细介绍。

2.2 开启线程的两种方式

方式一：调用内置的类

 

import time,random
from threading import Thread


def piao(name):
    print("%s is piaoing" % name)
    time.sleep(random.randrange(1,5))
    print("%s piao end" % name)


if __name__ =="__main__":
    t1 = Thread(target=piao,args=("egon",))

    t1.start()
    print("主进程") #每开一个进程，默认有一个线程
    #所以当前有一个进程一个线程

 

方式二：自定义类

import time
from threading import Thread


class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print("%s is piaoing" % self.name)
        time.sleep(2)
        print("%s is running" % self.name)


if __name__ == "__main__":
    t1 = MyThread("egon")
    t1.start()
    print("主进程")

三、多线程与多进程的区别

1 创建进程的开销远大于线程，可利用time模块来对比所耗时间。

from threading import Thread
import time

def work(start):
    stop = time.time()
    print("开启线程所用时间为%.5f秒" % (stop - start))


if __name__ == '__main__':
    start = time.time()
    t=Thread(target=work,args=(start,))
    t.start()


#运行结果如下：
开启线程所用时间为0.00050秒

from multiprocessing import Process
import time

def work(start):
    stop = time.time()
    print("开启子进程所用时间为%.5f秒" % (stop - start))


if __name__ == '__main__':
    start = time.time()
    p=Process(target=work,args=(start,))
    p.start()


#运行结果如下：
开启子进程所用时间为0.14338秒

2 在主进程下开启多个线程，各线程与主线程pid相同；而开启多个进程，每个进程都用不同的pid。因为同一进程内多个线程共享该进程的内存空间，而各进程间内存空间相互隔离。

from threading import Thread
import os

def work():
    print('hello',os.getpid())

if __name__ == '__main__':
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print('主线程/主进程pid',os.getpid())

运行结果如下：
hello 21188
hello 21188
主线程/主进程pid 21188

from multiprocessing import Process
import os

def work():
    print('hello',os.getpid())

if __name__ == '__main__':
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print('主线程/主进程',os.getpid())


#运行结果如下
主线程/主进程 22292
hello 1160
hello 23292

四、守护线程

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行。

1、对主进程来说，运行完毕指的是主进程代码运行完毕
2、对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

即：

1、主进程在其代码结束后就已经算运行完毕（守护进程在此时就被回收），然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)才会结束。
2、主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

验证如下：

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-------")


#运行结果如下
123
456
main-------
end123
end456

线程t1,t2洗后开启，打印出123,456.紧接着主线程打印出main-------。此时，主线程需要等待非守护线程t2结束，在此期间，t1线程打印end123，然后t2打印end456

 五、GIL全局解释器锁

GIL的全称是：Global Interpreter Lock,意思就是全局解释器锁，这个GIL并不是python的特性，他是只在Cpython解释器里引入的一个概念，而在其他的语言编写的解释器里就没有这个GIL。所以，GIL并不是Python的特性，Python完全可以不依赖于GIL。

GIL与Lock：

GIL本质也是互斥锁。锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据，而保护不同的数据就应该加不同的锁。所以，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock。

GIL与多线程：

cpu是用来做计算的。多cpu意味着可以有多个核并行完成计算，所以多核提升的是计算性能。但每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处。我们可以来验证。

from multiprocessing import Process
from threading import Thread
import os,time

def work():
    res=0
    for i in range(100000000):
        res*=i

if __name__ == '__main__':
    l=[]
    print(os.cpu_count()) #本机为4核
    start=time.time()
    for i in range(4):
        p=Process(target=work) #耗时4s多
        #p=Thread(target=work) #耗时17s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
    time.sleep(2)
    print('===>')

if __name__ == '__main__':
    l=[]
    print(os.cpu_count()) #本机为4核
    start=time.time()
    for i in range(400):
        p=Process(target=work) #耗时17s多,大部分时间耗费在创建进程上
        #p=Thread(target=work) #耗时2s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

结论：

多线程适用于IO密集型，如socket，爬虫，web。
多进程适用于计算密集型，如金融分析。

六、死锁和递归锁

6.1  死锁现象

所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。形象化的比喻：好比A、B两个人，A被锁在自己家里，手里只有B的房门钥匙，而B被锁在A家里，手里只有A的家门钥匙，此时，A、B就只能无尽的等待下去。

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('\033[41m%s 拿到A锁\033[0m' %self.name)

        mutexB.acquire()
        print('\033[42m%s 拿到B锁\033[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('\033[43m%s 拿到B锁\033[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('\033[44m%s 拿到A锁\033[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锁
#此时出现死锁，整个程序阻塞住

对上述代码的执行过程分析如下：

1. thread1首先抢到了A锁，此时thread1没有释放A锁，紧接着执行代码mutexB.acquire()，抢到了B锁。thread1在抢B锁时候，没有其他线程与thread1争抢，因为A锁没有释放，其他线程只能等待。
2. thread1继续往下执行，先后释放B锁，A锁，就执行完func1代码。然后继续执行func2代码，但是在func2中，执行代码 mutexB.acquire()抢到B锁后，然后进入睡眠状态。
3. 在thread1执行完func1的同时，thread2抢到了A锁，接下来要抢B锁，但是B锁被thread1获得，此时thread2在此处卡住。
4. thread1睡眠结束后往下走，需要抢A锁，但是A锁已被thread2获得尚未释放，所以thread1在此卡住。此时，整个程序出现死锁现象。

要想避免出现死锁，通过手动加锁和解锁，步骤繁琐，容易出错，此时引出递归锁的概念。

6.2 递归锁

递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁，二者的区别是：递归锁可以连续acquire多次，而互斥锁只能acquire一次。

from threading import Thread,RLock
import time

# mutexA=RLock()
# mutexB=mutexA
mutexB=mutexA=RLock()

class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print("%s 拿到了A锁"%self.name)

        mutexB.acquire()
        print("%s 拿到了B锁" % self.name)
        mutexB.release()

        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print("%s 拿到了B锁"%self.name)
        time.sleep(0.1)

        mutexA.acquire()
        print("%s 拿到了A锁" % self.name)
        mutexA.release()

        mutexB.release()

if __name__ =="__main__":
    for i in range(10):
        t = MyThread()
        t.start()

七、信号量、Event、定时器

7.1 信号量semaphore

信号量也是一把锁，它限定了可以同时有多少个任务拿到锁并执行。

semaphore是一个内置的计数器

• 每当调用acquire()时，内置计数器-1
• 每当调用release()时，内置计数器+1
• 计数器不能小于0，当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

from threading import Thread,Semaphore,currentThread
import time,random

sm = Semaphore(3)

def task():
    with sm:
        print("%s in" % currentThread().getName())
        time.sleep(random.randrange(1,3))

if __name__ == "__main__":
    for i in range(10):
        t = Thread(target=task)
        t.start()

执行上述代码可以发现，最多只允许3个线程同时运行。在实际工作中，为防止计算机泵机，可以引入信号量限制一个时间点内的线程数量。

7.2 事件Event

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行。所以，Event的主要作用就是用于主线程控制其他线程的执行。

Event用法：

event=threading.Event() #设置一个事件实例

event.set() #设置标志位

event.isSet()：返回event的状态值

event.clear() #清空标志位

event.wait()  #等待设置标志位

一个形象化的比喻：多个学生在上课，但是学生在上课期间不能做别的事，一定要等到老师发下课指令后，才可以休息。代码如下：

from threading import Thread,Event
import time

event = Event()
#event.wait()
#event.set()

def student(name):
    print("学生%s 正在听课" % name)
    event.wait()
    print("学生%s 正在休息" % name)

def teacher(name):
    print("老师%s 正在授课" % name)
    time.sleep(7)
    event.set()

if __name__ == "__main__":
    stu1 = Thread(target=student,args=("alex",))
    stu2 = Thread(target=student, args=("egon",))
    stu3 = Thread(target=student, args=("wxx",))
    stu4 = Thread(target=student, args=("john",))

    t1 = Thread(target=teacher,args=("chuan",))

    stu1.start()
    stu2.start()
    stu3.start()
    stu4.start()

    t1.start()

7.3 定时器

定时器，指定n秒后执行某操作。

from threading import Timer

def hello():
    print("hello, world")

t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed

八、线程queue

Queue模块实现了多生产者多消费者队列, 尤其适合多线程编程.Queue类中实现了所有需要的锁原语, Queue模块实现了三种类型队列:

• FIFO(先进先出)队列, 第一加入队列的任务, 被第一个取出；
• LIFO(后进先出)队列,最后加入队列的任务, 被第一个取出(操作类似与栈, 总是从栈顶取出)；
• PriorityQueue(优先级)队列, 保持队列数据有序, 最小值被先取出。

import queue

q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())


'''
结果(先进先出):
first
second
third
'''

import queue

q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())

'''
结果(后进先出):
third
second
first
'''

import queue

q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))

print(q.get())
print(q.get())
print(q.get())

'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''

九、进程池和线程池

concurrent.futures模块是用来创建并行的任务，提供了更高级别的接口，为了异步执行调用
ThreadPoolExecutor：线程池，提供异步调用
ProcessPoolExecutor: 进程池，提供异步调用

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time,random

def task(n):
    print('[%s] is running'%os.getpid())
    time.sleep(random.randint(1,3))  #I/O密集型的，，一般用线程，用了进程耗时长
    return n**2

if __name__ == '__main__':
    start = time.time()
    p = ProcessPoolExecutor()
    for i in range(10): #现在是开了10个任务， 那么如果是上百个任务呢，就不能无线的开进程，那么就得考虑控制线程数了，那么就得考虑到池了
        obj  = p.submit(task,i).result()  #submit提交任务,reslut(timeout=None)取得结果
    p.shutdown()  #相当于close和join方法
    print('='*30)
    print(time.time() - start)  #本机22秒

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time,random

def task(n):
    print('[%s] is running'%os.getpid())
    time.sleep(random.randint(1,3))
    return n**2

if __name__ == '__main__':
    start = time.time()
    p = ProcessPoolExecutor()
    l = []
    for i in range(10):
        obj = p.submit(task,i)
        l.append(obj)
    p.shutdown()
    print('='*30)
    print([obj.result() for obj in l])
    print(time.time() - start)  #本机执行5秒

总结：

1. 同步意味着有序，异步意味着无序；
2. 同步调用提交完任务后，就在原地等待任务执行完毕，拿到结果，再执行下一行代码,导致程序是串行执行；
3. 异步调用：提交完任务后，不等待任务执行完毕
4. 线程池与进程池使用方法类似

map方法

map(fn, *iterables, timeout=None)，第一个参数fn是线程执行的函数；第二个参数接受一个可迭代对象；第三个参数timeout跟wait()的timeout一样，但由于map是返回线程执行的结果，如果timeout小于线程执行时间会抛异常TimeoutError。map的返回是有序的，它会根据第二个参数的顺序返回执行的结果：

import time
from concurrent.futures import ThreadPoolExecutor


def get_thread_time(times):
    time.sleep(times)
    return times


start = time.time()
executor = ThreadPoolExecutor(max_workers=4)

i = 1
for result in executor.map(get_thread_time,[2,3,1,4]):
    print("task{}:{}".format(i, result))
    i += 1

#执行结果如下
task1:2
task2:3
task3:1
task4:4