- python的thread模块是比较底层的模块,python的threading模块是对thread做了一些包装的,可以更加方便的被使用
1. 使用threading模块
示例代码:
import time
import threading
# 线程共享全局变量
g_num = 10
g_nums = [1, 2]
def sing():
global g_num
g_num += 1
for i in range(5):
print("唱歌~")
time.sleep(1)
def dance(temp):
temp.append(21)
for i in range(5):
print("跳舞~")
time.sleep(1)
# 创建子线程,方法不要带()
# target指定调用哪个线程
# args 指定调用函数的时候传递什么参数过去,只有一个参数的时候也要(g_nums,)
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance, args=(g_nums,))
# 启动线程
# 线程的运行没有先后顺序
t1.start()
t2.start()
print(g_num)
print(g_nums)
# 查看线程个数
print(threading.enumerate())
总结
- 当调用
start()
时,才会真正的创建线程,并且开始执行 - 主线程会等待所有的子线程结束后才结束
- 查看线程个数使用
threading.enumerate()
2. 线程执行代码的封装
通过使用threading模块能完成多任务的程序开发,为了让每个线程的封装性更完美,所以使用threading模块时,往往会定义一个新的子类class,只要继承threading.Thread
就可以了,然后重写run
方法
示例如下:
#coding=utf-8
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
print(msg)
if __name__ == '__main__':
t = MyThread()
t.start()
总结
- python的threading.Thread类有一个run方法,用于定义线程的功能函数,可以在自己的线程类中覆盖该方法。而创建自己的线程实例后,通过Thread类的start方法,可以启动该线程,交给python虚拟机进行调度,当该线程获得执行的机会时,就会调用run方法执行线程。
3. 线程的执行顺序
#coding=utf-8
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm "+self.name+' @ '+str(i)
print(msg)
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
执行结果:(运行的结果可能不一样,但是大体是一致的)
I'm Thread-1 @ 0
I'm Thread-2 @ 0
I'm Thread-5 @ 0
I'm Thread-3 @ 0
I'm Thread-4 @ 0
I'm Thread-3 @ 1
I'm Thread-4 @ 1
I'm Thread-5 @ 1
I'm Thread-1 @ 1
I'm Thread-2 @ 1
I'm Thread-4 @ 2
I'm Thread-5 @ 2
I'm Thread-2 @ 2
I'm Thread-1 @ 2
I'm Thread-3 @ 2
总结
- 从代码和执行结果我们可以看出,多线程程序的执行顺序是不确定的。当执行到sleep语句时,线程将被阻塞(Blocked),到sleep结束后,线程进入就绪(Runnable)状态,等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数,但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。
4. 多线程-共享全局变量
from threading import Thread
import time
g_num = 100
def work1():
global g_num
for i in range(3):
g_num += 1
print("----in work1, g_num is %d---"%g_num)
def work2():
global g_num
print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = Thread(target=work1)
t1.start()
#延时一会,保证t1线程中的事情做完
time.sleep(1)
t2 = Thread(target=work2)
t2.start()
运行结果:
---线程创建之前g_num is 100---
----in work1, g_num is 103---
----in work2, g_num is 103---
列表当做实参传递到线程中
from threading import Thread
import time
def work1(nums):
nums.append(44)
print("----in work1---",nums)
def work2(nums):
#延时一会,保证t1线程中的事情做完
time.sleep(1)
print("----in work2---",nums)
g_nums = [11,22,33]
t1 = Thread(target=work1, args=(g_nums,))
t1.start()
t2 = Thread(target=work2, args=(g_nums,))
t2.start()
运行结果:
----in work1--- [11, 22, 33, 44]
----in work2--- [11, 22, 33, 44]
总结:
- 优点,在一个进程内的所有线程共享全局变量,很方便在多个线程间共享数据
- 缺点,线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱(即线程非安全)
5. 互斥锁
-
原因:当多个线程几乎同时修改某一个共享数据的时候,需要进行同步控制,否则会出现数据错误
-
作用:某个线程要更改共享数据时,先将其锁定,此时资源的状态为“锁定”,其他线程不能更改;直到该线程释放资源,将资源的状态变成“非锁定”,其他的线程才能再次锁定该资源。
threading模块中定义了Lock类,可以方便的处理锁定:
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 释放
mutex.release()
注意:
- 如果这个锁之前是没有上锁的,那么acquire不会堵塞
- 如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁,那么此时acquire会堵塞,直到这个锁被解锁为止
import threading
import time
g_num = 0
def test1(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test1---g_num=%d"%g_num)
def test2(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test2---g_num=%d"%g_num)
# 创建一个互斥锁
# 默认是未上锁的状态
mutex = threading.Lock()
# 创建2个线程,让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()
p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()
# 等待计算完成
while len(threading.enumerate()) != 1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
运行结果:
---test1---g_num=1909909
---test2---g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000
可以看到最后的结果,加入互斥锁后,其结果与预期相符。
总结
- 确保了某段关键代码只能由一个线程从头到尾完整地执行
- 阻止了多线程并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大地下降了
- 由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁
6. 多任务版udp聊天器
客户端1:
# -*- coding:utf-8 -*-
# Author GaoYuan
import socket
import threading
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_socket.bind(("192.168.1.118", 8891))
def send_data():
"""发送数据"""
while True:
content = input()
udp_socket.sendto(content.encode("utf-8"), ("192.168.1.118", 8892))
def recv_data():
"""接收数据"""
while True:
recv_data = udp_socket.recvfrom(1024)
print(recv_data)
threading.Thread(target=send_data).start()
threading.Thread(target=recv_data).start()
客户端2:
# -*- coding:utf-8 -*-
# Author GaoYuan
import socket
import threading
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_socket.bind(("", 8892))
def send_data():
"""发送数据"""
while True:
content = input()
udp_socket.sendto(content.encode("utf-8"), ("192.168.1.118", 8891))
def recv_data():
"""接收数据"""
while True:
recv_data = udp_socket.recvfrom(1024)
print(recv_data)
threading.Thread(target=send_data).start()
threading.Thread(target=recv_data).start()
网友评论