[Python]线程实例化；互斥锁；线程间通信

目录

1.使用threading创建线程

2.线程锁（互斥锁）

线程间通信

－－－－－－－－－－到此，结束－－－－－－－－－－－－

图穷匕见

---

1.使用threading创建线程

threading模块提供了一个Thread类来代表一个线程对象，语法格式为：

Thread([group[,target[,name[,args[,kwargs]]]]])#参数说明：    
 group: 暂时没有用法，是为后续版本保留的，不用在意    
 target：表示调用的对象，默认为none，用法：threading.Thread(target=调用的对象（调用类）)   
  name: 给当前线程命名，会默认创建一个Thread-N（N为线程数）不重要  
   args：一个传递给调用目标(target)的参数元组     
kwargs:传递给调用目标(target)的参数字典

我们创建一个具体可视化的脚本来演示线程，便于理解应用

import threading,time 
def mubiao():    
    for i in range(3):#调用此函数后可以将每个子进程执行三次        
        time.sleep(1)        
        print("现在正在执行线程"+threading.current_thread().name)#thrading.current_thread().name是正在执行线程的名称
if __name__ == '__main__':    
    print("--------start----------")    
    threads = [threading.Thread(target=mubiao)for i in range(4)]#使用Thread 方法为target调用的对象进程创建5个线程    
    for t in threads:        
        t.start()#以此语句开启线程    
    for t in threads:        
        t.join()#以此语句来结束线程    
    print("-----------end-------------")    

运行结果如下：

-----start----------
现在正在执行线程Thread-1
现在正在执行线程Thread-2
现在正在执行线程Thread-3
现在正在执行线程Thread-4
现在正在执行线程Thread-1
现在正在执行线程Thread-2
现在正在执行线程Thread-3
现在正在执行线程Thread-4
现在正在执行线程Thread-1
现在正在执行线程Thread-2
现在正在执行线程Thread-3
现在正在执行线程Thread-4
-----------end-------------

可以看出，Python的线程执行是无序的

所以，创建线程的简单语句就可以是：

import threading
threads = [threading.Thread(target = 你想为谁创建线程（函数）) for i in range(你想创建多少线程)]
for t in threads:
    t.start()
for t in threads:
    t.join()

2.线程锁（互斥锁）

由于线程可以对全局变量进行修改，由此可能会造成混乱，互斥锁（mutual exclusion缩写为Mutex）就可以把线程保护起来，在线程1解锁之前其它同进程下的线程将无法运行。

treading模块钟可以使用Lock类进行锁定

使用语法如下：

mutex = threrad.Lock() #使用此语句创建一个锁
mutex.acquire([blocking]) #acquire()方法进行锁定
mutex.release() #release()方法进行锁定

必要参数说明：blocking：单纯上锁是时不需要设置该值，或将该值设置为False时，无法锁定便返回False，锁定成功返回True

下面一段简单的演示代码

from threading import Thread,Lock
import time
num = 1000 #资源总数量为1000
def task():
    global num    
    mutex.acquire()#Lock on    
    temp = num #临时赋值    
    time.sleep(0.1) # 给主线程一个休眠时间
    num = temp-1
    print("抢夺成功，剩余资源数为："+str(num))
    mutex.release() #解锁
if __name__ == '__main__':
    mutex = Lock() #创建一个锁
    t_l = [] #初始一个列表,储存线程    
    for i in range(10): #创建十个子线程       
        t = Thread(target = task)
 #线程实例化
        t_l.append(t)        
        t.start()  #创建并存打开了线程    
        for t in  t_l:        
            t.join() #结束线程

有时使用线程锁会议发生“死锁”

原因可以这样描述：当锁A解锁条件为锁B解锁，同时锁B的解锁条件又是锁A解锁时，这两个锁就解不开了，就不举例了。

图源：明日科技 

线程间通信

线程间通信的目的是为了共享信息

子线程之间可以直接进行数据共享，我们通过以下代码进行验证：

from threading import Thread
import time
def fst():
    print("------thread1 begain----------")
    global m_num #声明一个函数内全局变量
    m_num += 50
    print("m_num全局变量的数值为："  +str(m_num))
    print("------thread1 end-------------")
    time.sleep(1)
def  tws():
    time.sleep(0.5)
    print("--------thread2 begain---------")
    global m_num
    m_num -= 50
    print("m_num全局变量参数的值是：" +str(m_num))
    print("--------thread2  end---------")
m_num = 100
if __name__ == '__main__':
    print("main thread begain")    
    print("当前全局变量m_num的值为：" +str(m_num))
    t1 = Thread(target=fst)
    t2= Thread(target = tws)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print("-------main thread end-----------")    

－－－－－－－－－－到此，结束－－－－－－－－－－－－

图穷匕见