Python系统编程之线程

最新推荐文章于 2021-12-26 23:54:26 发布

凌晨两点半还不回家

最新推荐文章于 2021-12-26 23:54:26 发布

阅读量186

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/qq_35654080/article/details/88567617

版权

python 专栏收录该内容

73 篇文章 0 订阅

订阅专栏

一.多线程-threading

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

1. 使用threading模块

单线程执行

"""单线程执行"""
import time

def saySorry():
    print('-----1-------')
    time.sleep(1)

if __name__=='__main__':
    for i in range(5):
        saySorry()

多线程执行

"""多线程执行"""
import threading
import time

def saySorry():
    print('--------2-------')
    time.sleep(1)

if __name__=='__main__':
    for i in range(5):
        t=threading.Thread(target=saySorry)
        t.start()

说明

可以明显看出使用了多线程并发的操作，花费时间要短很多
创建好的线程，需要调用start()方法来启动

线程导包的两种方式：

2. 主线程会等待所有的子线程结束后才结束

"""主进程等待所有的子进程才会结束"""
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print('正在唱歌...%d'%i)
        sleep(1)

def dance():
    for i in range(3):
        print('正在跳舞...%d'%i)
        sleep(1)

if __name__=='__main__':
    print('---开始---:%s'%ctime())

    t1=threading.Thread(target=sing)
    t2=threading.Thread(target=dance)


    t1.start()
    t2.start()

    print('---结束---：%s'%ctime())

3. 查看线程数量

"""查看线程数量"""
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print('正在唱歌...%d'%i)
        sleep(1)

def dance():
    for i in range(3):
        print('正在跳舞...%d'%i)
        sleep(1)

if __name__=='__main__':
    print('---开始---:%s'%ctime())

    t1=threading.Thread(target=sing)
    t2=threading.Thread(target=dance)


    t1.start()
    t2.start()

    while True:
        length=len(threading.enumerate())
        print('当前运行的线程数为：%d'%length)
        if length<=1:
            break
        sleep(0.5)

1、多个线程执行同一个函数，线程之间互不影响，并且主线程与子线程之间也互不影响，各自执行各自的代码

2、进程里面包含线程 —— 进程是资源分配的单位，线程是CPU调度的单位。

进程，能够完成多任务，比如在一台电脑上能够同时运行多个QQ

线程，能够完成多任务，比如一个QQ中的多个聊天窗口

3、主线程会等待所有的子线程结束后才结束

4. 线程执行代码的封装

通过上一小节，能够看出，通过使用threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
            print(msg)


if __name__ == '__main__':
    t = MyThread()
    t.start()

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
I'm Thread-1 @ 0
I'm Thread-1 @ 1
I'm Thread-1 @ 2

Process finished with exit code 0

说明

python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

5. 线程的执行顺序

#coding=utf-8
import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i)
            print(msg)
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
I'm Thread-1 @ 0
I'm Thread-4 @ 0
I'm Thread-3 @ 0
I'm Thread-5 @ 0
I'm Thread-2 @ 0
I'm Thread-1 @ 1
I'm Thread-4 @ 1
I'm Thread-5 @ 1
I'm Thread-2 @ 1
I'm Thread-3 @ 1
I'm Thread-1 @ 2
I'm Thread-4 @ 2
I'm Thread-3 @ 2
I'm Thread-5 @ 2
I'm Thread-2 @ 2

Process finished with exit code 0

说明

从代码和执行结果我们可以看出，多线程程序的执行顺序是不确定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

6. 总结

每个线程一定会有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
当线程的run()方法结束时该线程完成。
无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。
线程的几种状态

二.线程共享全局变量，互斥锁

from threading import Thread
import time

g_num=100

def work1():
    global  g_num
    for i in range(3):
        g_num+=1

    print('---in work1,g_num is %d'%g_num)

def work2():
    global g_num
    print('---in work2,g_num is %d'%g_num)

print('---线程创建之前g_num is %d'%g_num)

t1=Thread(target=work1)
t1.start()

time.sleep(1)

t2=Thread(target=work2)
t2.start()

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
---线程创建之前g_num is 100
---in work1,g_num is 103
---in work2,g_num is 103

Process finished with exit code 0

列表当做实参传递到线程中

from threading import Thread
import time

def work1(nums):
    nums.append(44)
    print("----in work1---",nums)


def work2(nums):
    #延时一会，保证t1线程中的事情做完
    time.sleep(1)
    print("----in work2---",nums)

g_nums = [11,22,33]

t1 = Thread(target=work1, args=(g_nums,))
t1.start()

t2 = Thread(target=work2, args=(g_nums,))
t2.start()

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
----in work1--- [11, 22, 33, 44]
----in work2--- [11, 22, 33, 44]

Process finished with exit code 0

总结：

在一个进程内的所有线程共享全局变量，能够在不适用其他方式的前提下完成多线程之间的数据共享（这点要比多进程要好）
缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）
线程优点：可以共享全局变量
缺点：用不好，易发生错乱现象（3种解决方案）
列表可当做实参传递到线程处理函数中
Python中实现多任务的三种方式：进程、线程、协程
综合实例：由于线程用不好会错乱，解决方法3种：

1、解决方法1（最简单）：

让预想的任务先执行完以后，可以使用time.sleep(2)，让其睡2秒，等上个任务执行完毕，再执行下个线程，就不会错乱。

from threading import Thread
import time


g_num=0

def test1():
    global g_num
    for i in range(1000000):
        g_num+=1
    print('---test1----%s'%g_num)

def test2():
    global g_num
    for i in range(1000000):
        g_num+=1
    print('---test2----%s'%g_num)

if __name__=='__main__':
    t1=Thread(target=test1)
    t1.start()


    time.sleep(2)

    t2=Thread(target=test2)
    t2.start()

    time.sleep(2)

    print('最后的全局变量是%s'%g_num)

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
---test1----1000000
---test2----2000000
最后的全局变量是2000000

Process finished with exit code 0

2、解决方法2: 再定义个全局变量 g_flag=1，用if条件判断

g_flag这个全局变量的作用：它是一种标志，如果值为1说明，任务test1还没有执行完；

如果值为0说明，任务test1执行完了

from threading import Thread
import time


g_num=0
g_flag=1

def test1():
    global g_num
    global g_flag
    if g_flag==1:
        for i in range(1000000):
            g_num+=1
        g_flag=0
    print('---test1----%s'%g_num)

def test2():
    global g_num
    while True:
        if g_flag!=1:
            for i in range(1000000):
                g_num+=1
            else:
                break
    print('---test2----%s'%g_num)

if __name__=='__main__':
    t1=Thread(target=test1)
    t1.start()


    #time.sleep(2)

    t2=Thread(target=test2)
    t2.start()

    time.sleep(2)

    print('最后的全局变量是%s'%g_num)

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
---test1----1000000
---test2----2000000
最后的全局变量是2000000

Process finished with exit code 0

3、解决方法3：互斥锁（知道用法，原理）

1、mutex不固定，可自己定义

2、from threading import Thread,Lock这种形式的导包，创建锁：mutex = Lock()

3、import threading 这种形式的导包，创建锁：mutex=threading.Lock()

4、mutex = acquire() 锁定、默认上锁

5、mutex = release() 解锁、释放

注意：

① 最好创建一个锁（靠谱不乱），每个函数下都要写上锁定、解锁命令，不然执行结果不对

② 有了互斥锁后，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了

③ 一把锁的话，只能把锁内的内容执行完后，解锁后，再执行下个任务。（循环多的话，还是一把锁靠谱）

④ 容易形成死锁，写程序时，要逻辑清晰，要避免死锁

from threading import Thread,Lock
import time

g_num=0
def test1():
    global g_num
    mutex.acquire()
    for i in range(1000000):
        g_num+=1
    mutex.release()

    print('---test1----%s'%g_num)

def test2():
    global g_num
    mutex.acquire()
    for i in range(1000000):
        g_num+=1
    mutex.release()

    print('---test2----%s'%g_num)

if __name__=='__main__':
    mutex=Lock()
    t1=Thread(target=test1)
    t1.start()


    #time.sleep(2)

    t2=Thread(target=test2)
    t2.start()

    time.sleep(2)

    print('最后的全局变量是%s'%g_num)

进程VS线程

功能

进程，能够完成多任务，比如在一台电脑上能够同时运行多个QQ
线程，能够完成多任务，比如一个QQ中的多个聊天窗口

定义的不同

进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

区别

一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
线线程不能够独立执行，必须依存在进程中

优缺点

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

三.多线程-非共享数据

对于全局变量，在多线程中要格外小心，否则容易造成数据错乱的情况发生

1. 非全局变量是否要加锁呢？

"""多线程使用非共享数据"""
from threading import Thread
import threading
import time

def test():
    name=threading.current_thread().name
    print('---thread name is %s ---'%name)
    g_num=100
    if name=='Thread-1':
        g_num+=1
    else:
        time.sleep(2)
    print('---thread is %s---g_num=%d'%(name,g_num))

if __name__=='__main__':
    t1=Thread(target=test)
    t1.start()

    t2=Thread(target=test)
    t2.start()

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
---thread name is Thread-1 ---
---thread is Thread-1---g_num=101
---thread name is Thread-2 ---
---thread is Thread-2---g_num=100

Process finished with exit code 0

"例2"
import threading
import time

class MyThread(threading.Thread):
    #重写方法
    def __init__(self,num,sleepTime):
        threading.Thread.__init__(self)
        self.num=num
        self.sleepTime=sleepTime

    def run(self):
        self.num+=1
        time.sleep(self.sleepTime)
        print('线程(%s),num=%d'%(self.name,self.num))

if __name__=='__main__':
    mutex = threading.Lock()
    t1=MyThread(100,5)
    t1.start()
    t2=MyThread(200,1)
    t2.start()

结果：

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
线程(Thread-2),num=201
线程(Thread-1),num=101

Process finished with exit code 0

小总结

在多线程开发中，全局变量是多个线程都共享的数据，而局部变量等是各自线程的，是非共享的

四. 死锁

1. 死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子


"""死锁"""
import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print(self.name+'---do1---up---')
            time.sleep(1)

            if mutexB.acquire():
                print(self.name+'---do1---down---')
                mutexB.release()
            mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print(self.name+'---do2---up---')
            time.sleep(1)

            if mutexA.acquire():
                print(self.name+'---do2--down--')
                mutexA.release()
            mutexB.release()


mutexA=threading.Lock()
mutexB=threading.Lock()

if __name__=='__main__':
    t1=MyThread1()
    t1.start()

    t2=MyThread2()
    t2.start()

2. 说明

3. 避免死锁

程序设计时要尽量避免（银行家算法）
添加超时时间等

附录-银行家算法

[背景知识]

一个银行家如何将一定数目的资金安全地借给若干个客户，使这些客户既能借到钱完成要干的事，同时银行家又能收回全部资金而不至于破产，这就是银行家问题。这个问题同操作系统中资源分配问题十分相似：银行家就像一个操作系统，客户就像运行的进程，银行家的资金就是系统的资源。

[问题的描述]

一个银行家拥有一定数量的资金，有若干个客户要贷款。每个客户须在一开始就声明他所需贷款的总额。若该客户贷款总额不超过银行家的资金总数，银行家可以接收客户的要求。客户贷款是以每次一个资金单位（如1万RMB等）的方式进行的，客户在借满所需的全部单位款额之前可能会等待，但银行家须保证这种等待是有限的，可完成的。

例如：有三个客户C1，C2，C3，向银行家借款，该银行家的资金总额为10个资金单位，其中C1客户要借9各资金单位，C2客户要借3个资金单位，C3客户要借8个资金单位，总计20个资金单位。某一时刻的状态如图所示。

对于a图的状态，按照安全序列的要求，我们选的第一个客户应满足该客户所需的贷款小于等于银行家当前所剩余的钱款，可以看出只有C2客户能被满足：C2客户需1个资金单位，小银行家手中的2个资金单位，于是银行家把1个资金单位借给C2客户，使之完成工作并归还所借的3个资金单位的钱，进入b图。同理，银行家把4个资金单位借给C3客户，使其完成工作，在c图中，只剩一个客户C1，它需7个资金单位，这时银行家有8个资金单位，所以C1也能顺利借到钱并完成工作。最后（见图d）银行家收回全部10个资金单位，保证不赔本。那麽客户序列{C1，C2，C3}就是个安全序列，按照这个序列贷款，银行家才是安全的。否则的话，若在图b状态时，银行家把手中的4个资金单位借给了C1，则出现不安全状态：这时C1，C3均不能完成工作，而银行家手中又没有钱了，系统陷入僵持局面，银行家也不能收回投资。

综上所述，银行家算法是从当前状态出发，逐个按安全序列检查各客户谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户，......。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。

五.同步

同步的概念

1. 多线程开发可能遇到的问题

假设两个线程t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。

但是由于是多线程访问，有可能出现下面情况：

在num=0时，t1取得num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

from threading import Thread
import time

g_num = 0

def test1():
    global g_num
    for i in range(1000000):
        g_num += 1

    print("---test1---g_num=%d"%g_num)

def test2():
    global g_num
    for i in range(1000000):
        g_num += 1

    print("---test2---g_num=%d"%g_num)


p1 = Thread(target=test1)
p1.start()

# time.sleep(3) #取消屏蔽之后 再次运行程序，结果会不一样，，，为啥呢？

p2 = Thread(target=test2)
p2.start()

print("---g_num=%d---"%g_num)

2. 什么是同步

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。

"同"字从字面上容易理解为一起动作

其实不是，"同"字应是指协同、协助、互相配合。

如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。

3. 解决问题的思路

对于本小节提出的那个计算错误的问题，可以通过线程同步来进行解决

思路，如下:

系统调用t1，然后获取到num的值为0，此时上一把锁，即不允许其他现在操作num
对num的值进行+1
解锁，此时num的值为1，其他的线程就可以使用num了，而且是num的值不是0而是1
同理其他线程在对num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

4.同步应用

"""同步应用"""

from  threading import Thread,Lock
import time

class Task1(Thread):
    def run(self):
        while True:
            if lock1.acquire():
                print('---Task 1----')
                time.sleep(0.5)
                lock2.release()
class Task2(Thread):
    def run(self):
        while True:
            if lock2.acquire():
                print('---Task2---')
                time.sleep(0.5)
                lock3.release()
class Task3(Thread):
    def run(self):
        while True:
            if lock3.acquire():
                print('---Task3---')
                time.sleep(0.5)
                lock1.release()

#使用Lock创建出的锁默认没有‘锁上’
lock1=Lock()

lock2=Lock()
lock2.acquire()

lock3=Lock()
lock3.acquire()

if __name__=='__main__':
    t1=Task1()
    t2=Task2()
    t3=Task3()


    t1.start()
    t2.start()
    t3.start()

D:\Anaconda\python.exe E:/pythonwork/黑马/系统编程之线程.py
---Task 1----
---Task2---
---Task3---
---Task 1----
---Task2---
---Task3---
---Task 1----
---Task2---
---Task3---
---Task 1----
---Task2---
---Task3---
---Task 1----
---Task2---
---Task3---
---Task 1----
---Task2---
---Task3---

总结

可以使用互斥锁完成多个任务，有序的进程工作，这就是线程的同步

六.生产者与消费者模式

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么就做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

用FIFO队列实现上述生产者与消费者问题的代码如下：

import threading
import time

#python2中
#from Queue import Queue

#python3中
from queue import Queue

class Producer(threading.Thread):
    def run(self):
        global queue
        count = 0
        while True:
            if queue.qsize() < 1000:
                for i in range(100):
                    count = count +1
                    msg = '生成产品'+str(count)
                    queue.put(msg)
                    print(msg)
            time.sleep(0.5)

class Consumer(threading.Thread):
    def run(self):
        global queue
        while True:
            if queue.qsize() > 100:
                for i in range(3):
                    msg = self.name + '消费了 '+queue.get()
                    print(msg)
            time.sleep(1)


if __name__ == '__main__':
    queue = Queue()

    for i in range(500):
        queue.put('初始产品'+str(i))
    for i in range(2):
        p = Producer()
        p.start()
    for i in range(5):
        c = Consumer()
        c.start()

3. Queue的说明

对于Queue，在多线程通信之间扮演重要的角色
添加数据到队列中，使用put()方法
从队列中取数据，使用get()方法
判断队列中是否还有数据，使用qsize()方法

4. 生产者消费者模式的说明

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，

七.ThreadLocal

在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好，因为局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁

1. 使用函数传参的方法

但是局部变量也有问题，就是在函数调用的时候，传递起来很麻烦：

def process_student(name):
    std = Student(name)
    # std是局部变量，但是每个函数都要用它，因此必须传进去：
    do_task_1(std)
    do_task_2(std)

def do_task_1(std):
    do_subtask_1(std)
    do_subtask_2(std)

def do_task_2(std):
    do_subtask_2(std)
    do_subtask_2(std)

每个函数一层一层调用都这么传参数那还得了？用全局变量？也不行，因为每个线程处理不同的Student对象，不能共享。

2. 使用全局字典的方法

如果用一个全局dict存放所有的Student对象，然后以thread自身作为key获得线程对应的Student对象如何？

global_dict = {}

def std_thread(name):
    std = Student(name)
    # 把std放到全局变量global_dict中：
    global_dict[threading.current_thread()] = std
    do_task_1()
    do_task_2()

def do_task_1():
    # 不传入std，而是根据当前线程查找：
    std = global_dict[threading.current_thread()]
    ...

def do_task_2():
    # 任何函数都可以查找出当前线程的std变量：
    std = global_dict[threading.current_thread()]

这种方式理论上是可行的，它最大的优点是消除了std对象在每层函数中的传递问题，但是，每个函数获取std的代码有点low。

有没有更简单的方式？

3. 使用ThreadLocal的方法

ThreadLocal应运而生，不用查找dict，ThreadLocal帮你自动做这件事：

import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('dongGe',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('老王',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()
执行结果：

Hello, dongGe (in Thread-A)
Hello, 老王 (in Thread-B)

说明

全局变量local_school就是一个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。

可以理解为全局变量local_school是一个dict，不但可以用local_school.student，还可以绑定其他变量，如local_school.teacher等等。

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

4. 小结

一个ThreadLocal变量虽然是全局变量，但每个线程都只能读写自己线程的独立副本，互不干扰。ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题

八.异步

同步调用就是你喊你朋友吃饭，你朋友在忙，你就一直在那等，等你朋友忙完了，你们一起去

异步调用就是你喊你朋友吃饭，你朋友说知道了，待会忙完去找你，你就去做别的了。

from multiprocessing import Pool
import time
import os

def test():
    print("---进程池中的进程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid()))
    for i in range(3):
        print("----%d---"%i)
        time.sleep(1)
    return "hahah"

def test2(args):
    print("---callback func--pid=%d"%os.getpid())
    print("---callback func--args=%s"%args)

pool = Pool(3)
pool.apply_async(func=test,callback=test2)

time.sleep(5)

print("----主进程-pid=%d----"%os.getpid())
运行结果：

---进程池中的进程---pid=9401,ppid=9400--
----0---
----1---
----2---
---callback func--pid=9400
---callback func--args=hahah
----主进程-pid=9400----

凌晨两点半还不回家

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python系统编程之线程

一.多线程-threadingpython的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用1. 使用threading模块单线程执行"""单线程执行"""import timedef saySorry(): print('-----1-------') time.sleep(1)...
复制链接

扫一扫