多线程编程
Thread方式
# 导包
import threading
import time
# 创建方法
def work(msg):
print(f"当前线程:{threading.current_thread().name}", msg)
time.sleep(1)
# 创建对象
for i in range(10):
t = threading.Thread(target=work, args=(i,))
t.start()
Thread类继承
import threading
# 创建一个类继承线程
class NewThread(threading.Thread):
def __init__(self, name):
# 调用父类的init方法
super(NewThread, self).__init__()
self.name = name
# run方法必须写
def run(self):
print(f"{self.name}好吃")
for i in ["包子", "牛肉", "鸡肉"]:
# 实例化对象
t = NewThread(i)
t.start()
线程和进程
线程：调度单元具体做事的那个人 共享内存空间 修改全局变量会影响 线程不安全 需要互斥锁
进程：程序的代码，其他的一些资源 每增加一个进程就会创建一份内存空间 修改全局变量不会有影响 通信麻烦 需要用队列
线程共享内存空间
import threading
num = 1
def write():
global num
num += 1
print(f"write里面的{num}")
def read():
global num
num += 1
print(f"read里面的{num}")
# 实例化
tw = threading.Thread(target=write)
tr = threading.Thread(target=read)
tw.start()
tr.start()
print("main里面的", num)
线程安全
import threading
num = 0
def write():
global num
for i in range(100000):
num += 1
print(f"write里面的{num}")
def read():
global num
for i in range(100000):
num += 1
print(f"read里面的{num}")
# 实例化
tw = threading.Thread(target=write)
tr = threading.Thread(target=read)
tw.start()
#tw.join()
tr.start()
#tr.join()
print("main里面的", num)
结果不等于200000
个人看法：进程的join方法，线程里面同样有，这样出来的结果就是200000
解决线程安全加互斥锁
某个线程要更改共享数据时，先将其锁定，此时资源的状态为”锁定“，其他线程不能更改；直到该线程释放资源，将资源的状态变成”非锁定“，其他线程才能再次锁定该资源。互斥锁保证了多线程下数据的正确性
import threading
num = 0
def write():
global num
#加锁
l.acquire()
for i in range(100000):
num += 1
#解锁
l.release()
print(f"write里面的{num}")
def read():
global num
#加锁
l.acquire()
for i in range(100000):
num += 1
#解锁
l.release()
print(f"read里面的{num}")
#创建一把锁
l = threading.Lock()
# 实例化
tw = threading.Thread(target=write)
tr = threading.Thread(target=read)
tw.start()
tr.start()
死锁
#coding=utf-8
import threading
import time
class MyThread1(threading.Thread):
def run(self):
if mutexA.acquire():
print(self.name+'----do1---up----')
time.sleep(1)
if mutexB.acquire():
#if mutexB.acquire(timeout=2):
print(self.name+'----do1---down----')
mutexB.release()
mutexA.release()
class MyThread2(threading.Thread):
def run(self):
if mutexB.acquire():
print(self.name+'----do2---up----')
time.sleep(1)
if mutexA.acquire():
print(self.name+'----do2---down----')
mutexA.release()
mutexB.release()
mutexA = threading.Lock()
mutexB = threading.Lock()
if __name__ == '__main__':
t1 = MyThread1()
t2 = MyThread2()
t1.start()
t2.start()
解决：添加超时时间
进程与线程
进程：独立内存空间，资源分配的单元
线程：共享内存空间 大大减少内存的使用 线程不安全 调试单元 最后做事的那个人
一个程序至少一个进程，至少一个线程
什么时候使用多进程，什么时候使用多线程
IO密集型：多线程（输入 输出 多用于数据传输）
CPU密集型：多进程（多用来做运算）
