题目：开启5个线程，每个线程循环输出一个字符串n次，例如5个线程分别循环输出a b c d e 各5次，要求每次输出都得等前一个字母输出完再输出，即最终结果应该是：abcedabcedabcedabced

特点：自己执行前需要判断其他线程执行结果，自己执行完也需要返回结果供别的线程执行前判断

关键点：线程并发执行，同时，每个线程都需要在自己的循环中等一个特定的条件，而不断的执行循环

思路：

一开始想到利用锁和全局变量，获取锁后读取判断全局变量，判断是否执行动作，然后给全局变量设置新的值，供其他线程使用

>>> import threading
>>> import time
>>> import random

>>> g=''
>>> lk=threading.Lock()
>>> def test(s,i):
	global g
	while i>0:
		with lk: #获取锁,
			time.sleep(random.random()) #模拟真实任务执行时间
			if s=='a': #这一层if/elif只是为了模拟该场景，为了不单独定义输出abcde的每个函数而偷懒
				if g=='' or g=='e': #这一层才是判断执行时机的关键
					print(s)
					g=s
					i-=1
			elif s=='b':
				if g=='a':
					print(s)
					g=s
					i-=1
			elif s=='c':
				if g=='b':
					print(s)
					g=s
					i-=1
			elif s=='d':
				if g=='c':
					print(s)
					g=s
					i-=1
			elif s=='e':
				if g=='d':
					print(s)
					g=s
					i-=1

	    
>>> ttt = [threading.Thread(target=test, args=(j,5)) for j in ('a','b','c','d','e')]
	    
>>> g=''
	    
>>> lk
<unlocked _thread.lock object at 0x00000272FDED90F8>

>>> for t in ttt: t.start()

>>> a
b
c
d
e
a
b
c
d
e
a
b
c
d
e
a
b
c
d
e
a
b
c
d
e
>>> 

也可以通过queue来实现，
总体而讲，这种方式实现的调度效率是相当低的，需要不停循环获取和释放锁，在期间判断是否执行，存在很多无效的“获得锁-判断--释放锁”的过程。

进一步研究，正解

用threading.Condition 这里面提到了wait()和notify()以及notify_all()方法，初步感觉，用notify_all()通知所有线程的话，至少每次通知都能让该执行的线程执行一次，理论上效率应该比上面“撞大运”的方式要高不少，具体怎样，试试就知道

>>> import threading
>>> import time
>>> import random

>>> def check(s,g):
		if s=='a':
			return True if g=='' or g=='e' else False
		elif s=='b':
			return True if g=='a' else False
		elif s=='c':
			return True if g=='b' else False
		elif s=='d':
			return True if g=='c' else False
		elif s=='e':
			return True if g=='d' else False

>>> def test11(s,i):
	global g
	while i>0:
		with cv:
			time.sleep(random.random())
			if s=='a': #这一层if/elif只是为了模拟该场景，为了不单独定义输出abcde的每个函数而偷懒,其下的逻辑才是本来应有的函数逻辑
				if check(s,g):
					print(s)
					g=s
					i-=1
					cv.notify_all()
				cv.wait()
			elif s=='b':
				if check(s,g):
					print(s)
					g=s
					i-=1
					cv.notify_all()
				cv.wait()
			elif s=='c':
				if check(s,g):
					print(s)
					g=s
					i-=1
					cv.notify_all()
				cv.wait()
			elif s=='d':
				if check(s,g):
					print(s)
					g=s
					i-=1
					cv.notify_all()
				cv.wait()
			elif s=='e':
				if check(s,g):
					print(s)
					g=s
					i-=1
					cv.notify_all()
				cv.wait()
	    
>>> g=''
>>> cv=threading.Condition()
>>> ttt = [ threading.Thread(target=test11, args=(j,5)) for j in ('a','b','c','d','e')]
>>> for t in ttt: t.start()
>>> a
b
c
d
e
a
b
c
d
e
a
b
c
d
e
a
b
c
d
e
a
b
c
d
e

执行起来看到，比第一种方式要快了太多，因为不会有无效的“获取锁-判断-释放锁”的过程了。

拓展：其实