Python3.x 多线程

实例如下：

#python多线程
#优点如下：
#1.使用线程可以把占据长时间的程序中的任务放到后台去处理
#2.用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可弹出一个进度条来显示处理进度
#3.程序运行速度可能加快
#4.在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可释放一些资源如内存占用等
#线程分为内核线程和用户线程；内核线程有操作系统内存创建和撤销，用户线程在用户程序中实现；线程可被强占，可睡眠
#Python3中线程常用的两个模块
#1._thread
#2.thrading(推荐使用)
#python使用线程有两种方式：函数或用类来包装线程对象

#函数式：调用_thread模块中的start_new_thread()函数来产生新线程：
#_thread.start_new_thread(function, args[, kwargs])
#function-线程函数
#args-传递给线程函数的参数，必须是tuple类型
#kwargs-可选参数

import _thread
import time

#为线程定义一个函数
def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s"%(threadName, time.ctime(time.time())))

#创建两个线程
try:
    _thread.start_new_thread(print_time, ("Thread-1", 2,))
    _thread.start_new_thread(print_time, ("Thread-2", 4,))
except:
    print("Error: 无法启动线程")
while 1:
    pass

#使用threading模块创建线程

import threading
import time
exitFlag = 0
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):
        print("开始线程： " + self.name)
        print_time(self.name, self.counter, 5)
        print("退出线程： " + self.name)

# 为线程定义一个函数
def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print("%s: %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()
print("退出主线程")


#线程同步
#使用Thread对象Lock和Rlock来实现简单的线程同步，这两个对象有acquire方法和release方法，对于那些需要每次只
#允许一个线程操作的数据，可以将其操作放到acquire和release方法之间。
#多线程优势在于可同时运行多个任务，但是当线程需要共享数据时，可能存在数据不同步问题。
import threading
import time

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):
        print("开始线程： " + self.name)
        #获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        #释放锁，开启下一个线程
        threadLock.release()
      #  print("退出线程： " + self.name)

# 为线程定义一个函数
def print_time(threadName, delay, counter):
    while counter:
       #if exitFlag:
         #   threadName.exit()
        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()
#thread1.join()
#thread2.join()
print("退出主线程")


#线程优先级队列
#Python的Queue模块中提供了同步的，线程安全的队列类，包括FIFO（先入先出）队列Queue，LIFO（后入先出）队列
#LifoQueue，和优先级队列PriorityQueue
#这些队列实现了锁原语，可在多线程中直接使用，不用额外做线程间同步
import threading
import time
import queue

exitFlag = 0
class myThread(threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print("开始线程： " + self.name)
        #print_time(self.name, self.q)
        process_data(self.name, self.q)
        print("退出线程： " + self.name)

# 为线程定义一个函数
def process_data(threadName,q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print("%s processing %s" %(threadName, 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
   #     print("%s: %s" % (threadName, time.ctime(time.time())))
 #       counter -= 1

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

#填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

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

#通知线程是时候退出
exitFlag = 1

#等待所有线程完成
for t in threads:
    t.join()
print("退出主线程")

#thread1 = myThread(1, "Thread-1", 1)
#thread2 = myThread(2, "Thread-2", 2)

#开启新线程
#thread1.start()
#thread2.start()
#thread1.join()
#thread2.join()
#print("退出主线程")

结果：

参考网页