python多线程编程

多线程技术--在当前IT编程中已经被广泛应用了，多数的开发语言已经拥有完美的多线程使用创建的环境，在此基本概念就不赘述了---自行百度。

python中使用多线程需要导入一个包 threading,具体如下案例:

# ###########函数式编程实现线程################
def target_():
    print("the current threading %s is running" %(threading.current_thread().name))
    time.sleep(1)
    print("the current threading %s is ended" %(threading.current_thread().name))

print("the current threading %s is running" %(threading.current_thread().name))

##属于线程t部分
t=threading.Thread(target=target_())
t.start()

#join相当于阻塞当前线程(此处当前线程为主线程)主线程直到thread-1结束之后才结束
t.join()

继承编程实现线程

# #继承父类threading.Thread 重写init run方法
class myThread(threading.Thread):
    def __init__(self,threadID,name,counter):
        threading.Thread.__init__(self)
        self.threadID=threadID
        self.name=name
        self.counter=counter

    def run(self):  #把要执行的代码写到run函数里
        print("Start "+self.name)
        self.print_time(self.name,self.counter,5)
        print("Exiting "+self.name)
    #类的普通方法
    def print_time(self,threadName,delay,counter):
        while counter:
            time.sleep(delay)
            print("%s process at: %s" %(threadName,time.ctime(time.time())))
            counter -= 1

thread1=myThread(1,"Thread-1",1)#创建线程
thread2=myThread(2,"Thread-2",2)#创建线程

thread1.start()
thread2.start()

thread1.join()
thread2.join()

线程间同步---------------------------------------------

       如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步
使用Thread对象的Lock和Rlock可以实现简单的线程同步，这两个对象都有acquire方法和release方法
Tips：Python有一个GIL（Global Interpreter Lock）机制，任何线程在运行之前必须获取这个全局锁才能执行，每当执行完100条字节码，全局锁才会释放，切换到其他线程执行

 多线程实现同步有四种方式：
锁机制------信号量-------条件判断--------同步队列

 ---锁机制   Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁---

 以代码为例:

import threading,time
class myThread(threading.Thread):
    def __init__(self,threadID,name,counter):
        threading.Thread.__init__(self)  #重写threading.Thread构造函数
        self.threadID=threadID
        self.name=name
        self.counter=counter
    def run(self):
        print("start:"+self.name)
        #获得锁，成功后返回True，可选的timeout参数不填时，会一直阻塞直到获得锁定，否则超时后会返回false
        threadLock.acquire()
        self.print_time(self.name,self.counter,5)
        #释放锁
        threadLock.release()
    def print_time(self,threadName,delay,counter):
        while counter:
            time.sleep(delay)
            print("%s:%s"%(threadName,time.ctime(time.time())))
            counter-=1
threadLock=threading.Lock()    #创建锁
threads=[]    #创建列表
thread1=myThread(1,"Thread-1",1) #创建线程类
thread2=myThread(2,"Thread-2",2)
thread1.start()
thread2.start()
threads.append(thread1)    #将线程添加进列表
threads.append(thread2)
for t in threads:    #遍历等待线程结束
    t.join()
print("Exit Main Thread")

线程同步队列queue
Python3.x中提供的是queue-------import queue.
Python的queue模块中提供了同步的、线程安全的队列类

包括FIFO（先入先出)队列Queue

LIFO（后入先出）队列LifoQueue

优先级队列PriorityQueue

 queue.qsize() 返回队列的大小
 queue.empty() 如果队列为空，返回True,反之False
 queue.full() 如果队列满了，返回True,反之False
 queue.full 与 maxsize 大小对应
 queue.get([block[, timeout]])获取队列，timeout等待时间
 queue.get_nowait() 相当Queue.get(False)
 queue.put(item) 写入队列，timeout等待时间
 queue.put_nowait(item) 相当Queue.put(item, False)
 queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
 queue.join() 实际上意味着等到队列为空，再执行别的操作

 以下是同步队列代码示例

import queue,threading,time

exitFlag=0
class myThread(threading.Thread):
    def __init__(self,threadID,name,mQ):
        threading.Thread.__init__(self)
        self.threadID=threadID
        self.name=name
        self.mQ=mQ
    def run(self):
        print("start :"+self.name)
        self.process_data(self.name,self.mQ)
        print("Exiting:"+self.name)
    def process_data(self,name,mQ):
        while not exitFlag:
            queueLock.acquire()
            if not workQueue.empty():
                data=mQ.get()
                queueLock.release()
                print("%s processing %s "%(name,data))
            else:
                queueLock.release()
            time.sleep(1)
threadList=["Thread-1","Thread-2","Thread-3"]
nameList=["one","two","three","four","five"]
queueLock=threading.Lock()
workQueue=queue.Queue(10)
threads=[]
threadID=1

#创建线程
for tName in threadList:
    thread=myThread(threadID,tName,workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

#等待队列清空
while not workQueue.empty():
    pass

exitFlag=1
#等待所有线程完成
for t in threads:
    t.join()

 线程同步最常见的解释方法是生产者与消费者的关系-------生产者----消费者问题--百度百科

###常见的生产者消费者
from queue import Queue
import  random,threading,time
###生产者
class Producer(threading.Thread):
    def __init__(self,name,queue):
        threading.Thread.__init__(self,name=name)
        self.data=queue
    def run(self):
        for i in range(5):
            print("%s is producer %d to the queue"%(self.getName(),i))
            self.data.put(i)
            time.sleep(random.randrange(10)/5)
        print("%s finished!"%self.getName())

###消费者
class Consumer(threading.Thread):
    def __init__(self,name,queue):
        threading.Thread.__init__(self,name=name)
        self.data=queue

    def run(self):
        for i in range(5):
            val=self.data.get()
            print("%s is consuming %d in the queue is consumed" %(self.getName(),val))
            time.sleep(random.randrange(10))
        print("%s finished "%self.getName())
def main():
    queue=Queue()
    producer=Producer('Producer',queue)
    consumer=Consumer('Consumer',queue)

    producer.start()
    consumer.start()
    producer.join()
    consumer.join()

if __name__=='__main__':
    main()