python 线程/线程锁/信号量

#常规写法import threading
import timedef sayhi(num): # 定义每个线程要运行的函数
print("running on number:%s" % num)
time.sleep()if __name__ == '__main__':
t1 = threading.Thread(target=sayhi, args=(,)) # 生成一个线程实例
t2 = threading.Thread(target=sayhi, args=(,)) # 生成另一个线程实例 t1.start() # 启动线程
t2.start() # 启动另一个线程 print(t1.getName()) # 获取线程名
print(t2.getName())自定义线程类
import threading
import timeclass MyThread(threading.Thread):
def __init__(self, num):
threading.Thread.__init__(self) self.num = num def run(self): # 定义每个线程要运行的函数
print("running on number:%s" % self.num)
time.sleep()if __name__ == '__main__':
t1 = MyThread()
t2 = MyThread() t1.start()
t2.start()

import threading
import timedef sayhi(num): # 定义每个线程要运行的函数
print("running on number:%s" % num)
time.sleep()start_time=time.time()
if __name__ == '__main__':
for i in range(): ###多线程
t = threading.Thread(target=sayhi, args=(i,)) # 生成一个线程实例
t.start()
print (start_time-time.time()) ####打印时间此时打印结果时间为0.0000几秒，是因为程序在执行完多线程时继续往下执行，而不会等待线程执行完在打印时间，所以打印出来的时间并不是多线程执行的时间join（）
线程执行后，主线程会等待所有线程执行完毕后继续往下走，下面实例介绍计算多线程执行时间import threading
import timedef sayhi(num): # 定义每个线程要运行的函数 print("running on number:%s" % num)
time.sleep()start_time=time.time()threads = [] ####定义一个列表，将所有的线程加进去
if __name__ == '__main__':
for i in range(): ###多线程
t = threading.Thread(target=sayhi, args=(i,)) # 生成一个线程实例
t.start()
threads.append(t) ####将每个线程添加到列表
for t in threads: ###循环整个列表，进行join（每个线程join完成后主线程才会继续往下走）
t.join() ###等待所有线程执行结束，相当于单线程print (start_time-time.time())

#!/usr/bin/env python
#-*-coding:utf--*-import threading
from time import ctime,sleep
import timedef music(func):
for i in range():
print ("Begin listening to %s. %s" %(func,ctime()))
sleep()
print("end listening %s"%ctime())def move(func):
for i in range():
print ("Begin watching at the %s! %s" %(func,ctime()))
sleep()
print('end watching %s'%ctime())threads = []
t1 = threading.Thread(target=music,args=('music',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('movie',))
threads.append(t2)if __name__ == '__main__': for t in threads:
t.start()
print ("all over %s" %ctime())

###没有加锁时import threading
import time,sysdef addNum():
global num # 在每个线程中都获取这个全局变量
print('--get num:', num)
time.sleep()
num -= # 对此公共变量进行-1操作num = # 设定一个共享变量
thread_list = []for i in range():
t = threading.Thread(target=addNum)
t.start()
thread_list.append(t)
for t in thread_list: # 等待所有线程执行完毕 t.join()
print('final num:', num)说明：
正常来讲，这个num结果应该是0， 但在python 2.7上多运行几次，会发现，最后打印出来的num结果不总是0，为什么每次运行的结果不一样呢？
假设你有A,B两个线程，此时都 要对num 进行减1操作， 由于2个线程是并发同时运行的，所以2个线程很有可能同时拿走了num=100这个初始变量交给cpu去运算，当A线程去处完的结果是99，但此时B线程运算完的结果也是99，两个线程同时CPU运算的结果再赋值给num变量后，结果就都是99。那怎么办呢？ 很简单，每个线程在要修改公共数据时，为了避免自己在还没改完的时候别人也来修改此数据，可以给这个数据加一把锁， 这样其它线程想修改此数据时就必须等待你修改完毕并把锁释放掉后才能再访问此数据。加锁版本：import threading
import timegl_num =
lock = threading.RLock() ## 生成全局锁def Func():
lock.acquire() #修改数据前加锁
global gl_num
gl_num +=
time.sleep()
print(gl_num)
lock.release() ###修改后释放for i in range():
t = threading.Thread(target=Func)
t.start()

import threading, timedef run1():
print("grab the first part data")
lock.acquire()
global num
num += 1
lock.release() return numdef run2():
print("grab the second part data")
lock.acquire()
global num2
num2 += 1
lock.release() return num2def run3():
lock.acquire()
res = run1()
print('--------between run1 and run2-----')
res2 = run2()
lock.release()
print(res, res2)if __name__ == '__main__':
num, num2 = 0, 0
lock = threading.RLock() for i in range(10):
t = threading.Thread(target=run3)
t.start()while threading.active_count() != 1:
print(threading.active_count())else: print('----all threads done---')
print(num, num2)

lock_con=threading.Condition([Lock/Rlock])： 锁是可选选项，不传人锁，对象自动创建一个RLock()。

wait()：条件不满足时调用，线程会释放锁并进入等待阻塞；
notify()：条件创造后调用，通知等待池激活一个线程；
notifyAll()：条件创造后调用，通知等待池激活所有线程。

import threading, timedef run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread: %s" % n)
semaphore.release()if __name__ == '__main__':
num = 0
semaphore = threading.BoundedSemaphore(5) # 最多允许5个线程同时运行，有一个执行完毕后会执行另一个
for i in range(20):
t = threading.Thread(target=run, args=(i,))
t.start()