python之threading模块简单讲解和实例演示

Posted 2020-09-02

import threading

 

 

在处理一些程序时为了节约时间，可以使用多线程的方式，

让其并发去执行，从而节约时间，

（注意python其实是伪多线程，其实是以我们感觉不到的速度每行代码都按照相同时间执行）

 

 

 

 

 

 

 

 

 

Lock

当多线程同时对一个变量进行修改操作的时候，那么可能会出现混乱，

因为其是并发（算是吧）而行，

（所以当两个赋值时间相对接近时那么其容易出现混乱）

所以我们得创建锁，

让其上一个线程赋值结束，

下一个赋值再继续

 

 

threading.Lock() 创建锁

是可用的最低级的同步指令。

Lock处于锁定状态时，不被特定的线程拥有。

Lock包含两种状态--锁定和非锁定，以及两个基本的方法

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。

池中的线程处于状态图中的同步阻塞状态

 

acquire(blocking=True,timeout=-1)

使线程进入同步阻塞状态，尝试获得锁定

 

blocking：为True时，将阻塞直至锁变成unblocked，然后设置它的状态为locked并返回True。

为False时，将不会阻塞。如果阻止设置为True的调用将被阻止，请立即返回False；否则，将锁定设置为锁定并返回True。

锁定

 

 

 

release()

 

释放一把锁，这可以从任何线程调用，而不仅仅是已经获得锁的进程

 

 

 

 

---------------------------------------------------------

 

Thread

对某段代码实行多线程，

线程表示其里面的代码同时进行，

也就是说上下两个代码同时进行，

当执行完本条代码就会去执行父程序代码，

所以这样就可能会出现混乱，

所以我们得设置join让其把所有子进程执行完，

再执行父进程

 

 

threading.Thread(group=None,target=None,name=None,args=(),kwargs={},*,daemon=None)

线程类，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖run()

 

 

group：线程组，目前还没有 实现

target： 要执行的方法，就是要执行的程序

是将被run()方法调用的可调用对象。默认为None，表示不调用任何东西

name：线程的名字，默认情况下以Thread-N的形式构造一个唯一的名字，N是一个小的十进制整数

args：给调用程序传入的值（）

kwargs：给程序传入的值，默认为{}

 

 

 

Thread.name

线程名

 

Thread.ident

线程的标识符

 

Thread.daemon

布尔标志，表示这个线程是否是守护线程

 

 

start()

开始线程活动

 

 

 

 

isAlive()

返回线程是否正在运行。

 

get/setName(name)

获取/设置后台线程（默认前台线程False）

现在使用thread.name属性，或者在实例化过程中传递该属性

 

 

 

 

is/setDaemon(bool)

获取/设置是否守护进程。

初始值从创建该线程的线程继承

并没有非守护线程仍在运行时，程序将终止

已经弃用

现在使用thread.daemom属性

 

 

setDaemon(True)

（将线程声明为守护进程，必须在start()方法调用之前设置，如果不设置为守护线程程序会被无限挂起。

字线程启动后，父线程也继续执行，当父线程执行完最后一条语句后，没有等待子进程，直接就退出了，同时子线程也一同结束）

 

 

 

join([timeout])

直至启动的线程终止之前一直挂起；除非给出了timeout，否则会一直阻塞

也就是等上面的程序都执行完了，再执行下面的程序

（对于一些程序，可以用此方法来解决数据混乱问题，但是其需要一次次关闭，很浪费时间）

（理解线程：程序先上下执行，如果遇到循环则丢给第二个线程来执行）

-----------------------------------------------------------------

 

Condition

条件变量，通过与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例

可以认为，除了Lock带有的锁定池外，Condition还包含一个等待池，池中的线程处于状态图中的等待阻塞状态，直到另一个线程调用notify()/notifyAll()通知；得到通知后线程进入锁定池等待锁定

 

构造方法：

Condition([lock/rlock])

wait([timeout]): 调用这个方法将使线程进入Condition的等待池等待通知，并释放锁。使用前线程必须已获得锁定，否则将抛出异常。 

notify(): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）；其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。 

notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常

 

 

 

 

 

----------------------------------------------------------------------------

threading.currentThread()

返回当前的线程变量

 

 

 

threading.enumerate()

 

返回一个包含正在运行的线程的List

正在运行指线程启动后，结束前，不包括启动前和终止后的线程

 

 

 

threading.activeCount()

返回正在运行的线程数量，与len(threading.enumerate())有相同的效果

 

 

threading.TIMEOUT_MAX

设置threading全局超时时间

 

 ----------------------------------------------------------------------------------------------------------------------------------------------------

 

import threading 导入模块

 

lock=threading.Lock() 创建锁

a=0

thre=[]

def qwer():

　　lock.acquire() 对其锁定

　　global a 设置全局变量

　　a+=1

　　print(a)

　　lock.release() 对其解锁

 

for i in range(10):

　　t=threading.Thread(target=qwer) 创建线程

　　thre.append(t) 加入列表

　　t.start() 启动线程

for t in thre:

　　t.join() #等什么执行完了再执行下面的

 

　　print(6666666666)