一、普通的顺序执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
from
time
import
sleep, ctime
def
loop0():
print
"start loop 0 at:"
, ctime()
sleep(
4
)
print
"loop 0 done at:"
, ctime()
def
loop1():
print
"start loop 1 at:"
, ctime()
sleep(
2
)
print
"loop 1 done at:"
, ctime()
def
main():
print
"start at:"
, ctime()
loop0()
loop1()
print
"all DONE at:"
, ctime()
if
__name__
=
=
'__main__'
:
main()
|
执行结果
/usr/bin/python2.7 /home/toby/PycharmProjects/SOMS/test.py
start at: Tue Feb 28 20:57:02 2017
start loop 0 at: Tue Feb 28 20:57:02 2017
loop 0 done at: Tue Feb 28 20:57:06 2017
start loop 1 at: Tue Feb 28 20:57:06 2017
loop 1 done at: Tue Feb 28 20:57:08 2017
all DONE at: Tue Feb 28 20:57:08 2017
从结果来看所需要的时间为6秒
二、用线程执行（thread模块）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import
thread
from
time
import
sleep, ctime
def
loop0():
print
"start loop 0 at:"
, ctime()
sleep(
4
)
print
"loop 0 done at:"
, ctime()
def
loop1():
print
"start loop 1 at:"
, ctime()
sleep(
2
)
print
"loop 1 done at:"
, ctime()
def
main():
print
"start at:"
, ctime()
thread.start_new_thread(loop0,())
thread.start_new_thread(loop1,())
sleep(
6
)
print
"all DONE at:"
, ctime()
if
__name__
=
=
'__main__'
:
main()
|
执行结果：
/usr/bin/python2.7 /home/toby/PycharmProjects/SOMS/test.py
start at: Tue Feb 28 21:19:07 2017
start loop 0 at: Tue Feb 28 21:19:07 2017
start loop 1 at: Tue Feb 28 21:19:07 2017
loop 1 done at: Tue Feb 28 21:19:09 2017
loop 0 done at: Tue Feb 28 21:19:11 2017
all DONE at: Tue Feb 28 21:19:13 2017
从结果来看，函数loop0和loop1是在统一时间（21:19:07）启动，也就是并发执行。函数loop0等待时间为4秒，loop1等待时间为2秒，所以总的运行时间被缩短了，运行了两个函数花了4秒的时间。看看sleep(6)，使用了这样的一种愚蠢的方式来做线程同步机制，之所以是6，是因为我们已经知道了一个是4秒，一个是2秒，所以主线程等待6秒，那么两个函数也就都执行完了，否则，会发生子线程还没执行完，主线程就退出了。那么这是不能容忍的
三、使用线程和锁
如果，每一个线程的运行时间不能确定。那么如何解决？难道要让主线程过早或过晚的退出吗？解决上面那个愚蠢的问题（线程同步），就引用锁（GIL）来解决
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
#_*_coding:utf-8_*_
import
thread
from
time
import
sleep,ctime
#秒数
loops
=
[
4
,
2
]
#这个函数是模拟一个实实在在是用来干活的函数
def
loop(nloop,nsec,lock):
print
"函数%s 启动时间:%s 等待秒数:%s 获得的锁:%s\n"
%
(nloop,ctime(),nsec,lock)
sleep(nsec)
#等待时间
lock.release()
#释放锁
def
main():
print
"主线程在 %s 开始启动...:"
%
ctime()
locks
=
[]
#这个列表用来存放获得的锁
nloops
=
range
(
len
(loops))
#把全局变量中的loops列表引进来，所生成的局部变量nloops作为索引
#顾nloops存储的是[0,1,2]
#创建锁
for
i
in
nloops:
lock
=
thread.allocate_lock()
#创建一个锁的列表
lock.acquire()
#获得锁
locks.append(lock)
#把锁放到locks列表中
#创建线程
for
i
in
nloops:
thread.start_new_thread(loop,(i,loops[i],locks[i]))
#启动线程执行loop函数，i为循环编号，loops[i]为秒数，locks[i]为锁
#这个循环处于等待，达到暂停主线程的目的
#只要locks列表中存在锁，那么就是为true，所以会执行while循环，但是这个循环是pass，意思是啥都不干，只是空等着
for
i
in
nloops:
while
locks[i].locked():
pass
print
"所有函数完成时间:"
, ctime()
if
__name__
=
=
'__main__'
:
main()
|
执行结果：
"D:\Program Files (x86)\Python27\python27.exe" E:/PycharmProjects/test.py
主线程在 Wed Mar 01 12:52:03 2017 开始启动...:
函数0 启动时间:Wed Mar 01 12:52:03 2017 等待秒数:4 获得的锁:<thread.lock object at 0x0000000002C2E130>
函数1 启动时间:Wed Mar 01 12:52:03 2017 等待秒数:2 获得的锁:<thread.lock object at 0x0000000002C2E110>
所有函数完成时间: Wed Mar 01 12:52:07 2017
最后。。。
建议使用threading模块，这里建议使用thread模块仅作为研究之用。
