__thread模块

基础知识 开启一个新线程

_thread.start_new_thread(function, args[, kwargs]) 

例如

import _thread,time
def child(tid):
    print('Hello from thread', tid)
def parent():
    i = 0
    _thread.start_new_thread(child, (i,))
    time.sleep(3)
    print('hhe')
if __name__ == '__main__':
    parent()
>>>

Hello from thread 0
hhe  #(3s之后)

###
本例中载入_thread模块和创建线程并调用。
_thread.start_new_thread调用本身立即返回一个没有用的值，它派生出来的线程在其运行函数返回后安静的退出。用_thread模块时，大多数系统平台上整个程序退出时随之退出。上例中如果把time.sleep(3)的代码注释，则新线程的输出可能不成功。主线程就结束了，分线程也会随之结束

import \_thread, time
def action(i):                                       
    print(i ** 32)
class Power:
    def __init__(self, i):
        self.i = i
    def action(self):                               
        print(self.i ** 32)

_thread.start_new_thread(action, (2,))  #绑定简单函数             
_thread.start_new_thread((lambda: action(2)), ())   #绑定lambda表达式
obj = Power(2)
_thread.start_new_thread(obj.action, ())     #绑定方法对象        
time.sleep(2)
print('Main thread exiting.')       
###
在线程中对实例对象的状态做出任何改变，对于所有其他线程都是可见的           

同时运行多个线程

import _thread as thread, time
def counter(myId, count):                        # 线程中运行的程序
    for i in range(count):
        time.sleep(1)                            # 模拟耗时操作
        print('[%s] => %s' % (myId, i))

for i in range(5):                               # 开启5个线程
    thread.start_new_thread(counter, (i, 5))     # 每个线程中循环5次
time.sleep(6)
print('Main thread exiting.') 

线程所的概念
避免多个线程同时争夺同意资源而必须采用线程锁。

基础知识

mutex = _thread.allocate_lock()  创建锁

mutex.acquire()使用锁
.....操作要处理的对象
mutext.release()  释放锁

示例代码

import \_thread as thread, time

def counter(myId, count):                        
    for i in range(count):
        time.sleep(1)                            
        mutex.acquire()                                 #用锁
        print('[%s] => %s' % (myId, i))         
        mutex.release()                                  #解锁

mutex = thread.allocate_lock()                   # 创建一个全局锁
for i in range(5):                              
    thread.start_new_thread(counter, (i, 5))    
time.sleep(6)
print('Main thread exiting.')  

可以根据线程锁的状态来判断某个线程有没有完成耗时操作

import _thread as thread
stdoutmutex = thread.allocate_lock()
exitmutexes = [thread.allocate_lock() for i in range(10)]
#exitmutexes = [False]*10
def counter(myId, count):
    for i in range(count):
        stdoutmutex.acquire()
        print('[%s] => %s' % (myId, i))
        stdoutmutex.release()
    exitmutexes[myId].acquire()    # 标记myId线程完成任务 
    #exitmutexes[myId] = True

for i in range(10):
    thread.start_new_thread(counter, (i, 100))
for mutex in exitmutexes:                      #实时检测状态锁的状态。一旦全部锁住表示所有线程都完成任务。则循环完成
    while not mutex.locked(): pass
#while False in exitmutexes:pass 
print('Main thread exiting.')

threading

threading模块在内部使用_thread模块来实现代表线程的对象以及常用同步化工具的功能

import threading

class Mythread(threading.Thread):             # 继承Thread的子类
    def __init__(self, myId, count, mutex):
        self.myId  = myId
        self.count = count                     
        self.mutex = mutex                     # 传递来的线程锁
        threading.Thread.__init__(self)
    def run(self):                                   # 真正线程做的工作
        for i in range(self.count):            # 同步化 with语句线程锁
            with self.mutex:
                print('[%s] => %s' % (self.myId, i))

stdoutmutex = threading.Lock()                 #线程锁
threads = []
for i in range(10):
    thread = Mythread(i, 100, stdoutmutex)    
    thread.start()                             # 开始运行新的线程
    threads.append(thread)
for thread in threads:
    thread.join()                              # 等待线程结束 join
print('Main thread exiting.')

threading模块里的线程用Thread对象实现，通过提供定义线程的run方法来进行定制Python类Mythread，当我们创建一个Mythread类实例并调用其start方法时，run方法将在新的线程中执行。
Thread.join()方法可等待线程退出，采用这个方法避免主线程在子线程之前退出。

其他编程方法 可以直接利用Thread的默认run方法直接调用传给构造器的target参数的可调用对象aciton，args参数为传递给action的参数

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

import threading
def action(i):print(i**32)
thread = threading.Thread(target=action,arg=(2,))
thread.start()  #执行action

queue模块
queue模块提供一个标准的队列数据结构---一个先进先出的Python对象列表。队列对象自动有线程锁获取和释放操作控制，在任意给定时间只有一个线程能够修改队列

numconsumers = 2                
numproducers = 4                 
nummessages  = 4                
import _thread as thread, queue, time
safeprint = thread.allocate_lock()   
dataQueue = queue.Queue()             # 共享全局变量，没有限制大小 可以传参限制大小
def producer(idnum, dataqueue):
    for msgnum in range(nummessages):
        time.sleep(idnum)
        dataqueue.put('[producer id=%d, count=%d]' % (idnum, msgnum))        #放入队列

def consumer(idnum, dataqueue):
    while True:
        time.sleep(0.1)
        try:
            data = dataqueue.get(block=False)       #从队列里取值，如果队列为空者引发异常
        except queue.Empty:
            pass
        else:
            with safeprint:        #线程锁
                print('consumer', idnum, 'got =>', data)

if __name__ == '__main__':
    for i in range(numconsumers):
        thread.start_new_thread(consumer, (i, dataQueue))
    for i in range(numproducers):
        thread.start_new_thread(producer, (i, dataQueue))
    time.sleep(((numproducers-1) * nummessages) + 1)  #保证主线程最后退出
    print('Main thread exit.')