线程的有两种使用方法，一种是在函数使用，一种是放在类中使用。
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
.
|