假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。是的，这种机制就是线程。
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。

 1 #调用方式1
 2 import threading
 3 import time
 4
 5 def look():
 6     print("看dog")  # 1
 7     time.sleep(3)  # t1遇到IO睡3秒 线程切换到t2
 8     print("看dog结束") # 3
 9 def walk():
10     print("开始walking") #2
11     time.sleep(5)   # t2遇到IO睡五秒  线程切换到t1
12     print("walking结束")   #4
13     print("程序运行时间：%s"%(time.time()-s)) #5
14 s=time.time()
15 t1 = threading.Thread(target=look) #创建t1对象
16 t2 = threading.Thread(target=walk)  #创建t2对象
17 t1.start()
18 t2.start()

import threading
import time
#调用方式2 ，继承threading类
class MyThread(threading.Thread): #继承threading模块下的Thread类def __init__(self,num):threading.Thread.__init__(self) #继承父类的init方法self.num = numdef run(self):  #重写父类的run方法print("running on number:%s"%self.num)time.sleep(3)print("结束")
t1 = MyThread(100)
t2 = MyThread(200)
t1.start()
print("ending")
t2.start()#执行结果
running on number:100
ending
running on number:200
结束
结束

# join()：在子线程完成运行之前，这个子线程的父线程将一直被阻塞。# setDaemon(True)：'''将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就分兵两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以 用setDaemon方法啦'''import threading
from time import ctime,sleep
import timedef Music(name):print ("Begin listening to {name}. {time}".format(name=name,time=ctime()))sleep(3)print("end listening {time}".format(time=ctime()))def Blog(title):print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))sleep(5)print('end recording {time}'.format(time=ctime()))threads = []t1 = threading.Thread(target=Music,args=('FILL ME',))
t2 = threading.Thread(target=Blog,args=('',))threads.append(t1)
threads.append(t2)if __name__ == '__main__':#t2.setDaemon(True)for t in threads:#t.setDaemon(True) #注意:一定在start之前设置
        t.start()#t.join()#t1.join()#t2.join()    #  考虑这三种join位置下的结果？print ("all over %s" %ctime())

import time,threadingdef subnum():global num  #全局变量#num-=1#print("ok")#lock.acquire() #锁定开始，获取temp = numtime.sleep(0.0000001)num = temp - 1#lock.release()  #锁定结束，释放

num = 100
thread_list = []
lock = threading.Lock()  #创建一把锁for i in range(100):t = threading.Thread(target=subnum)t.start()thread_list.append(t)
for l in thread_list:l.join()print("result:",num)

import threading
import timemutexA = threading.Lock()
mutexB = threading.Lock()class MyThread(threading.Thread):def __init__(self):threading.Thread.__init__(self)def run(self):self.fun1()self.fun2()def fun1(self):mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))mutexB.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))mutexB.release()mutexA.release()def fun2(self):mutexB.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))time.sleep(0.2)mutexA.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))mutexA.release()mutexB.release()if __name__ == "__main__":print("start---------------------------%s"%time.time())for i in range(0, 10):my_thread = MyThread()my_thread.start()

import threading
import time# mutexA = threading.Lock()
# mutexB = threading.Lock()
rlock = threading._RLock()class MyThread(threading.Thread):def __init__(self):threading.Thread.__init__(self)def run(self):self.fun1()self.fun2()def fun1(self):#mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放
        rlock.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))#mutexB.acquire()
        rlock.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))#mutexB.release()
        rlock.release()#mutexA.release()
        rlock.release()def fun2(self):#mutexB.acquire()
        rlock.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))time.sleep(0.2)# mutexA.acquire()
        rlock.acquire()print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))#mutexA.release()
        rlock.release()#mutexB.release()
        rlock.release()if __name__ == "__main__":print("start---------------------------%s"%time.time())for i in range(0, 10):my_thread = MyThread()my_thread.start()

'''创建一个“队列”对象import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数
maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。将一个值放入队列中
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，
put方法将引发Full异常。将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且
block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。'''

'''
join() 阻塞进程，直到所有任务完成，需要配合另一个方法task_done。def join(self):with self.all_tasks_done:while self.unfinished_tasks:self.all_tasks_done.wait()task_done() 表示某个任务完成。每一条get语句后需要一条task_done。import queue
q = queue.Queue(5)
q.put(10)
q.put(20)
print(q.get())
q.task_done()
print(q.get())
q.task_done()q.join()print("ending!")
'''

'''Python Queue模块有三种队列及构造函数: 1、Python Queue模块的FIFO队列先进先出。  class queue.Queue(maxsize)
2、LIFO类似于堆，即先进后出。           class queue.LifoQueue(maxsize)
3、还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize) import queue#先进后出q=queue.LifoQueue()q.put(34)
q.put(56)
q.put(12)#优先级
q=queue.PriorityQueue()
q.put([5,100])
q.put([7,200])
q.put([3,"hello"])
q.put([4,{"name":"alex"}])while 1:data=q.get()print(data)'''

import time,random
import queue,threadingq = queue.Queue()def Producer(name):count = 0while count <10:print("making........")time.sleep(random.randrange(3))q.put(count)print('Producer %s has produced %s baozi..' %(name, count))count +=1#q.task_done()#q.join()print("ok......")
def Consumer(name):count = 0while count <10:time.sleep(random.randrange(4))if not q.empty():data = q.get()#q.task_done()#q.join()print(data)print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))else:print("-----no baozi anymore----")count +=1p1 = threading.Thread(target=Producer, args=('A',))
c1 = threading.Thread(target=Consumer, args=('B',))
# c2 = threading.Thread(target=Consumer, args=('C',))
# c3 = threading.Thread(target=Consumer, args=('D',))
p1.start()
c1.start()
# c2.start()
# c3.start()