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