# -*- coding: UTF-8 -*-
import thread
import time
# start_new_thread(function,args, kwargs=None) 生成一个新的线程
# allocate_lock() 分片locktype锁对象
# exit() 给线程退出指令
# acquire(wait=None) 尝试获取锁的对象
# locked() 如果获取了锁对象则返回True, 否则，返回False
# release() 释放锁
def loop0():
print "start loop 0 at:", time.ctime()
time.sleep(4)
print "loop 0 done at:", time.ctime()
def loop1():
print 'start loop 1 at', time.ctime()
time.sleep(2)
print "loop 1 done at:", time.ctime()
def main():
print "starting at: ", time.ctime()
# loop0()
# loop1()
thread.start_new(loop0, ())
thread.start_new(loop1, ())
time.sleep(6)
print "all Done at: ", time.ctime()
#不加线程时，需要6-7s,通过线程后，脚本运行只需要4s
if __name__ == '__main__':
main()
# -*- coding: UTF-8 -*-
# -*- coding: UTF-8 -*-
import thread
import time
# 使用线程和锁。
# 通过使用锁，可以在所有线程全部完成执行后立即退出。
# start_new_thread(function,args, kwargs=None) 生成一个新的线程，使用给定的args和可选的kwargs来执行function
# allocate_lock() 分配locktype锁对象
# exit() 给线程退出指令
# acquire(wait=None) 尝试获取锁的对象
# locked() 如果获取了锁对象则返回True, 否则，返回False
# release() 释放锁
loops = [4, 2]
def loop(nloop, nsec, lock):
print "start loop 0 at:", time.ctime()
time.sleep(nsec)
print "loop", nloop, 'done at:', time.ctime()
lock.release()
def main():
print 'starting at:', time.ctime()
locks = []
nloops = range(len(loops))
for i in nloops:
#分配锁，获取锁对象
lock = thread.allocate_lock()
#取得每一个锁，相当于将“把锁锁上”，锁上之后，将锁添加到锁列表locks中
lock.acquire()
locks.append(lock)
for i in nloops:
#调用函数loop(),并传递3个参数：
# i, 对应loop(nloop, nsec, lock):的nloop
# loops[i], 对应loop(nloop, nsec, lock):的nsec
# locks[i]：锁对象,对应函数lock参数
thread.start_new(loop, (i, loops[i], locks[i]))
for i in nloops:
while locks[i].locked():
pass
print 'all Done at:', time.ctime()
if __name__ == '__main__':
main()
#输出
# starting at: Thu May 12 23:37:28 2022
# start loop 0 at: start loop 0 at:Thu May 12 23:37:28 2022
# Thu May 12 23:37:28 2022
# loop 1 done at: Thu May 12 23:37:30 2022
# loop 0 done at: Thu May 12 23:37:32 2022
# all Done at: Thu May 12 23:37:32 2022
# -*- coding: UTF-8 -*-
import threading
import time
# threadming模块
# thread，表示执行一个线程的对象
# lock,锁对象,和thread模块中的锁一样
# Rlock,可重入锁对象，使单一线程可以再次获得已持有的锁（递归锁）
# Condition,条件变量对象，使得一个线程等等另一个线程满足特定的条件，比如改变状态或者某一个值
# Even,条件变量的通用版本，任意数量的线程等待某一个事件的发生，在该事件发生后所有线程将被激活
# Semaphore: 为线程间共享的有限资源提供一个计数器，如果没有可用资源时会被阻塞
# BoundSemaphore: 与Semaphore相似，不过他不允许超过初始值
# Timer: 与Thread相似，不过它要在运行前等待一段时间
# Barrier: 创建一个障碍，必须达到指定数量的线程后才可以继续
# thread模块：不支持守护线程，当主线程结束后，所有子线程都终止。
# threading.Thread对象属性
# name, 线程名
# ident: 线程标识符
# daemon: 布尔标志，表示这个线程是否是守护线程
# threading.Thread对象方法
# __init__(group=None, target=None, name=None, args=(), kwargs={}, verbase=None, daemon=None)
# 实例化一个线程对象，需要一个可调用的target，以及其参数args或kwargs，还可以传递name或group参数。
# 此外verbose 标志也可以接受
# daemon的值将会设定为thread.daemon属性/标志
# start()，开始执行线程
# run()，定义线程功能，通常在子类中被应用重写
# join(timeout=None)，直到启动的线程终止之前一直挂起，除非给出了timeout（秒），否则会一直阻塞
# getName()，返回线程名
# setName()，设定线程名
# isAlive/is_alive()，布尔标志，表示这个线程是否存活
# isDaemon()，如果是守护线程，则返回True，否则返回False
# setDaemon(daemon)，把线程的守护标志设定为布尔值 daemonic（必须在线程 start()之前调用）
loops = [4, 2]
def loop(nloop, nsec):
print 'start loop', nloop, 'at:', time.ctime()
time.sleep(nsec)
print 'loop', nloop, 'done at:', time.ctime()
def main():
print 'starting at:', time.ctime()
threads = []
nloops = range(len(loops))
for i in nloops:
t = threading.Thread(target=loop, args=(i, loops[i]))
threads.append(t)
for i in nloops:
threads[i].start()
for i in nloops:
threads[i].join()
print 'all done at:', time.ctime()
if __name__ == "__main__":
main()
#输出结果
# starting at: Fri May 13 00:22:22 2022
# start loop 0 at: Fri May 13 00:22:22 2022
# start loop 1 at: Fri May 13 00:22:22 2022
# loop 1 done at: Fri May 13 00:22:24 2022
# loop 0 done at: Fri May 13 00:22:26 2022
# all done at: Fri May 13 00:22:26 2022
