python 多線程 及多線程通訊，互斥鎖,線程池

一、簡單的多線程例子

import threading,time
def b_fun(i):
    print "____________b_fun start"
    time.sleep(7)
    print "________________b_fun end"

def a_fun():
    print "__________a_fun start"
    t = threading.Thread(target=b_fun, args=(1,))
    # t.setDaemon(True)  #setDaemon()設置爲False和沒有這句話一個意思，設置爲True，就是主線程a_fun函數不登t這個子線程了，a運行完，無論t運行完沒有，a和t都結束，且setDaemon必須放在start()前面

    t.start()
    print "__________1",
    # t.join(3)  #join()小括號中設置3的意思是，主線程a_fun函數運行到這的時候，等子線程t 3秒鐘，三秒鐘後無論子線程t結束沒，a都繼續運行下去，執行到return，主線程結束時子線程還能夠繼續在運行，直到結束
                                # 若是join小括號中沒有設置，就表明，主線程在這個地方一直等着子線程結束後，主線程才繼續執行下去
                                #若是這個地方沒有join()這個方法，就表明，主線程不等子線程，主線程直接運行下去

    print "__________a結束"
    return "返回值"
cc=a_fun()
print cc


二、帶通訊的多線程
這種狀況主要是，當一個多線程，開了幾個子線程，想知道幾個子線程的執行狀況的時候用到

#帶通訊的多線程  Queue(隊列，先進先出)
import threading,Queue,time
q=Queue.Queue()

def c1(a1):
    time.sleep(7)
    print a1
    q.put("c1 put 的內容")#put 存入到隊列中 

def c2(a1):
    time.sleep(4)
    print a1
    q.put("c2 put 的內容")# put 存入到隊列中

def a1():
    print "a1開始_______"
    cs1="第一個子線程cs1"
    t1=threading.Thread(target=c1,args=(cs1,))
    t1.start()

    cs2="第二個子線程cs2"
    t2=threading.Thread(target=c2,args=(cs2,))
    t2.start()
    qq=q.get()  #獲取隊列中的內容，並刪除
    if qq:　　　　　　#若是隊列中有內容，說明兩個隊列已經執行一個了
        print qq

a1()

若是在a1中想判斷 兩個線程是否都執行完了，能夠用
　　while True:
　　　　if q.qsize()==2:
　　　　　　print q.qsize()
　　　　　　print q.get()
　　　　　　break

三、生產消費模式

# encoding=utf-8
import threading
import time

# python2中
from Queue import Queue

#python3中
# from queue import Queue

class Producer(threading.Thread):
    def run(self):
        global queue
        count = 0
        while True:
            if queue.qsize() < 1000:
                for i in range(10):
                    count = count +1
                    msg = '生成產品'+str(count)
                    queue.put(msg)
                    print(msg)
            time.sleep(0.5)

class Consumer(threading.Thread):
    def run(self):
        global queue
        while True:
            if queue.qsize() > 100:
                for i in range(3):
                    msg = self.name + '消費了 '+queue.get()
                    print(msg)
            time.sleep(1)


if __name__ == '__main__':
    queue = Queue()

    for i in range(10):
        queue.put('初始產品'+str(i))
    for i in range(2):
        p = Producer()  #生產
        p.start()
    for i in range(5):
        c = Consumer()  #消費
        c.start()

四、互斥鎖

from threading import Thread, Lock
import time

g_num = 0

def test1():
    global g_num
    for i in range(1000000):
        #True表示堵塞 即若是這個鎖在上鎖以前已經被上鎖了，那麼這個線程會在這裏一直等待到解鎖爲止
        #False表示非堵塞，即無論本次調用可以成功上鎖，都不會卡在這,而是繼續執行下面的代碼
        mutexFlag = mutex.acquire(True)
        if mutexFlag:
            g_num += 1
            mutex.release()

    print("---test1---g_num=%d"%g_num)

def test2():
    global g_num
    for i in range(1000000):
        mutexFlag = mutex.acquire(True) #True表示堵塞
        if mutexFlag:
            g_num += 1
            mutex.release()

    print("---test2---g_num=%d"%g_num)

#建立一個互斥鎖
#這個所默認是未上鎖的狀態
mutex = Lock()

p1 = Thread(target=test1)
p1.start()

p2 = Thread(target=test2)
p2.start()

print("---g_num=%d---"%g_num)


五、線程池

from multiprocessing import Pool import time import os def test(): print("---進程池中的進程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid())) for i in range(3): print("----%d---"%i) time.sleep(1) return "hahah" def test2(args): print("---callback func--pid=%d"%os.getpid()) print("---callback func--args=%s"%args) pool = Pool(3) pool.apply_async(func=test,callback=test2) #func 調用的函數，callback 回調的函數 time.sleep(5) print("----主進程-pid=%d----"%os.getpid())