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 cc
2、带通信的多线程
这种情况主要是，当一个多线程，开了几个子线程，想知道几个子线程的执行情况的时候用到
#带通信的多线程 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())