线程、进程和协程（一）-白红宇

线程、进程和协程（一）

阅读量：4881 次

发布时间：2019-06-11

本文共 3455 字，大约阅读时间需要 11 分钟。

Python线程

Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。

                            
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import
threading
import
time
 
def
show(arg):
    
time.sleep(
1
)
    
print
'thread'
+
str
(arg)
 
for
i 
in
range
(
10
):
    
t 
=
threading.Thread(target
=
show, args
=
(i,))
    
t.start()
 
print
'main thread stop'
         
       

上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。

更多方法：

- start 线程准备就绪，等待CPU调度
- setName 为线程设置名称
- getName 获取线程名称
- setDaemon 设置为后台线程或前台线程（默认）
  如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
  如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
- join 逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
- run 线程被cpu调度后自动执行线程对象的run方法

1 import threading 2 import time 3   4   5 class MyThread(threading.Thread): 6     def __init__(self,num): 7         threading.Thread.__init__(self) 8         self.num = num 9  10     def run(self):#定义每个线程要运行的函数11  12         print("running on number:%s" %self.num)13  14         time.sleep(3)15  16 if __name__ == '__main__':17  18     t1 = MyThread(1)19     t2 = MyThread(2)20     t1.start()21     t2.start()

自定义线程类

线程锁（Lock、RLock）

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。

#!/usr/bin/env python# -*- coding:utf-8 -*-import threadingimport timegl_num = 0def show(arg):    global gl_num    time.sleep(1)    gl_num +=1    print gl_numfor i in range(10):    t = threading.Thread(target=show, args=(i,))    t.start()print 'main thread stop'

未使用锁

1 #!/usr/bin/env python 2 #coding:utf-8 3     4 import threading 5 import time 6     7 gl_num = 0 8     9 lock = threading.RLock()10    11 def Func():12     lock.acquire()13     global gl_num14     gl_num +=115     time.sleep(1)16     print gl_num17     lock.release()18        19 for i in range(10):20     t = threading.Thread(target=Func)21     t.start()

信号量（Semaphore）

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

                            
import
threading,time
def run(n):
    
semaphore.acquire()
    
time.sleep(1)
    
print(
"run the thread: %s"
%n)
    
semaphore.release()
if
__name__ == 
'__main__'
:
    
num= 0
    
semaphore  = threading.BoundedSemaphore(5)
#最多允许5个线程同时运行
    
for
i 
in
range(20):
        
t = threading.Thread(target=run,args=(i,))
        
t.start()
         
       

事件（event）

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False

set：将“Flag”设置为True

                            
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import
threading
def
do(event):
    
print
'start'
    
event.wait()
    
print
'execute'
event_obj 
=
threading.Event()
for
i 
in
range
(
10
):
    
t 
=
threading.Thread(target
=
do, args
=
(event_obj,))
    
t.start()
event_obj.clear()
inp 
=
raw_input
(
'input:'
)
if
inp 
=
=
'true'
:
    
event_obj.
set
()
         
       

条件（Condition）

使得线程等待，只有满足某条件时，才释放n个线程

                            
import
threading
def run(n):
    
con.acquire()
    
con.wait()
    
print(
"run the thread: %s"
%n)
    
con.release()
if
__name__ == 
'__main__'
:
    
con = threading.Condition()
    
for
i 
in
range(10):
        
t = threading.Thread(target=run, args=(i,))
        
t.start()
    
while
True:
        
inp = input(
'>>>'
)
        
if
inp == 
'q'
:
            
break
        
con.acquire()
        
con.notify(int(inp))
        
con.release()
         
       

View Code

Timer

定时器，指定n秒后执行某操作

                            
from threading 
import
Timer
def hello():
    
print(
"hello, world"
)
t = Timer(1, hello)
t.start()
# after 1 seconds, "hello, world" will be printed
         
       

转载于:https://www.cnblogs.com/now-playing/p/8453508.html

你可能感兴趣的文章