python 线程池 锁_python 多线程 及多线程通信，互斥锁,线程池

1、简单的多线程例子

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 cc2、带通信的多线程

这种情况主要是，当一个多线程，开了几个子线程，想知道几个子线程的执行情况的时候用到

#带通信的多线程 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

3、生产消费模式

# 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()

4、互斥锁

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)

5、线程池

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())