线程的有两种使用方法,一种是在函数使用,一种是放在类中使用。
1,在函数中使用多线程
语法如下:
1
|
thread
.
start_new_thread
(
function
,
args
[
,
kwargs
]
)
|
参数说明:
1
2
3
|
function
-线程函数。
args
-传递给线程函数的参数
,必须是个
tuple类型。
kwargs
-可选参数。
|
下面是一个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
def
run
(
num
)
:
print
'hi , i am a thread.'
,
num
def
main
(
)
:
threads
=
[
]
for
i
in
range
(
5
)
:
t
=
threading
.
Thread
(
target
=
run
,
args
=
(
i
,
)
)
threads
.
append
(
t
)
t
.
start
(
)
for
t
in
threads
:
t
.
join
(
)
if
__name__
==
'__main__'
:
print
'start -->'
main
(
)
print
'go here -->'
|
运行结果:
1
2
3
4
5
6
7
|
start
--
>
hi
,
i
am
a
thread
.
0
hi
,
i
am
a
thread
.
1
hi
,
i
am
a
thread
.
2
hi
,
i
am
a
thread
.
3
hi
,
i
am
a
thread
.
4
go
here
--
>
|
2,在类中多使用线程
下面是在类中使用线程的示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class
MyThread
(
threading
.
Thread
)
:
def
__init__
(
self
,
num
)
:
self
.
num
=
num
super
(
MyThread
,
self
)
.
__init__
(
)
def
run
(
self
)
:
print
'i am a thread,'
,
self
.
num
time
.
sleep
(
1
)
def
main
(
)
:
threads
=
[
]
for
i
in
range
(
5
)
:
t
=
MyThread
(
i
)
threads
.
append
(
t
)
t
.
start
(
)
for
t
in
threads
:
t
.
join
(
)
if
__name__
==
'__main__'
:
print
'start -->'
main
(
)
print'
go
here
--
>
|
- run(),需要重写,编写代码实现所需要的功能。
- getName(),获得线程对象名称
- setName(),设置线程对象名称
- start(),启动线程
- join([timeout]),等待另一线程结束后再运行。
- setDaemon(bool),设置子线程是否随主线程一起结束,必须在
start()
之前调用,默认为False
。 - isDaemon(),判断线程是否随主线程一起结束。
- isAlive(),检查线程是否在运行中。
join
方法的作用是阻塞主进程(无法执行join
以后的语句),主线程等待这个线程结束后,才可以执行下一条指令。多线程多join
的情况下,依次执行各线程的join
方法,前头一个结束了才能执行后面一个。无参数,则等待到该线程结束,才开始执行下一个线程的join
。设置参数后,则等待该线程这么长时间就不管它了(而该线程并没有结束)。不管的意思就是可以执行后面的主进程了。
3,线程同步与互斥锁
线程之所以比进程轻量,其中一个原因就是他们共享内存。也就是各个线程可以平等的访问内存的数据,如果在短时间“同时并行”读取修改内存的数据,很可能造成数据不同步。例如下面的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
var
=
0
class
IncreThread
(
Thread
)
:
def
run
(
self
)
:
global
var
print
'before,var is '
,
var
var
+=
1
print
'after,var is '
,
var
def
use_incre_thread
(
)
:
threads
=
[
]
for
i
in
range
(
50
)
:
t
=
IncreThread
(
)
threads
.
append
(
t
)
t
.
start
(
)
for
t
in
threads
:
t
.
join
(
)
print
'After 10 times,var is '
,
var
if
__name__
==
'__main__'
:
use_incre_thread
(
)
|
有一个全局变量var
,五十个线程,每个线程对var
变量进行加 1 运算,但是当你多运行几次后,发现并不是每次的运行结果都是 50,为什么呢?
在
var
是 10 的时候,线程t1
读取了var
,这个时刻cpu
将控制权给了另一个线程t2
。t2
线程读到的var
也是 10,t1
和t2
都把var
加到 11,当时我们期望的是t1 t2
两个线程使var
+ 2 变成 12。在这里就有了资源竞争,相同的情况也可能发生在其它的线程间,所以出现了最后的结果小于 50 的情况。
为了避免线程不同步造成数据不同步,可以对资源进行加锁。也就是访问资源的线程需要获得锁,才能访问。threading
模块提供了一个 Lock
功能,修改代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
var
=
0
lock
=
Lock
(
)
#创建锁
class
IncreThread
(
Thread
)
:
def
run
(
self
)
:
global
var
lock
.
acquire
(
)
#获取锁
print
'before,var is '
,
var
var
+=
1
print
'after,var is '
,
var
lock
.
release
(
)
#释放锁
def
use_incre_thread
(
)
:
threads
=
[
]
for
i
in
range
(
50
)
:
t
=
IncreThread
(
)
threads
.
append
(
t
)
t
.
start
(
)
for
t
in
threads
:
t
.
join
(
)
print
'After 10 times,var is '
,
var
if
__name__
==
'__main__'
:
use_incre_thread
(
)
|
虽然线程可以共享内存,但是一个线程不能影响其他线程内的变量(非全局变量)。
4,死锁
在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。尽管死锁很少发生,但一旦发生就会造成应用的停止响应。下面是一个死锁的例子:
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
|
mutex_a
=
Lock
(
)
mutex_b
=
Lock
(
)
class
MyThread
(
Thread
)
:
def
task_b
(
self
)
:
if
mutex_a
.
acquire
(
)
:
print
'thread get a mutex_a'
,
self
.
name
time
.
sleep
(
1
)
if
mutex_b
.
acquire
(
)
:
print
'get a mutex_b'
,
self
.
name
mutex_b
.
release
(
)
mutex_a
.
release
(
)
def
task_a
(
self
)
:
if
mutex_b
.
acquire
(
)
:
print
'thread get a mutex_b'
,
self
.
name
time
.
sleep
(
1
)
if
mutex_a
.
acquire
(
)
:
print
'get a mutex_a'
,
self
.
name
mutex_a
.
release
(
)
mutex_b
.
release
(
)
def
run
(
self
)
:
self
.
task_a
(
)
self
.
task_b
(
)
if
__name__
==
'__main__'
:
threads
=
[
MyThread
(
)
for
i
in
range
(
2
)
]
print
threads
for
t
in
threads
:
t
.
start
(
)
|
线程需要执行两个任务,两个任务都需要获取锁,当两个任务得到锁后,就需要等另外锁释放。
5,可重入锁
为了支持在同一线程中多次请求同一资源,python
提供了可重入锁(RLock
)。RLock
内部维护着一个Lock
和一个counter
变量,counter
记录了acquire
的次数,从而使得资源可以被多次require
。直到一个线程所有的acquire
都被release
,其他的线程才能获得资源。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
mutex
=
threading
.
RLock
(
)
class
MyThread
(
threading
.
Thread
)
:
def
run
(
self
)
:
if
mutex
.
acquire
(
1
)
:
print
'threading gte mutex:'
,
self
.
name
time
.
sleep
(
1
)
mutex
.
acquire
(
)
mutex
.
release
(
)
mutex
.
release
(
)
def
main
(
)
:
print
'start main threading:'
threads
=
[
MyThread
(
)
for
i
in
range
(
2
)
]
for
t
in
threads
:
t
.
start
(
)
for
t
in
threads
:
t
.
join
(
)
print
'end main threading.'
if
__name__
==
'__main__'
:
main
(
)
|
6,后台线程
使用多线程默认情况下,当主线程退出之后,即使子线程没有 join
,子线程也依然会继续执行。如果希望主线程退出后,其子线程也退出而不再执行,则需要设置子线程为后台线程。python
提供了setDaemon
方法,将子线程与主线程进行绑定,当主线程退出时子线程的生命也随之结束。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
MyThread
(
threading
.
Thread
)
:
def
run
(
self
)
:
wait_time
=
random
.
randrange
(
1
,
10
)
print
'thread %s will wait %s s'
%
(
self
.
name
,
wait_time
)
time
.
sleep
(
wait_time
)
time
.
sleep
(
30
)
print
'thread %s finished.'
%
self
.
name
def
main
(
)
:
print
'start thread:'
for
i
in
range
(
3
)
:
t
=
MyThread
(
)
t
.
setDaemon
(
1
)
t
.
start
(
)
print
'end thread.'
if
__name__
==
'__main__'
:
main
(
)
|
运行结果:
1
2
3
4
5
|
start
thread
:
thread
Thread
-
1
will
wait
9
s
thread
Thread
-
2
will
wait
1
s
thread
Thread
-
3
will
wait
7
s
end
thread
.
|