目录

• 线程

  • 一.什么是线程？
  • 二.开设线程的两种方式
    • 线程对象的其他方法
  • 三.守护线程
    • 定义
    • 小练习
  • 四.线程数据共享
  • 五.线程互斥锁

线程

我们可以把进程理解成一个资源空间，真正被CPU执行的就是进程里的线程。

一个进程中最少会有一条线程，同一进程下的每个线程之间资源是共享的。

开设进程需要做哪些操作
1.重新申请一块内存空间
2.将所需的资源全部导入
开设线程需要做哪些操作
上述两个步骤都不需要 所以开设线程消耗的资源远比开设进程的少!!!

from threading import Thread  # 线程模块
import time
# 正常方法
def test(name):
    print(f'{name} is running')
    time.sleep(2)
    print(f'{name} is over')

t = Thread(target=test, args=('jason',))
t.start()
print('主线程')

# 重写类方法
class Myclass(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f'{self.name} is running')
        time.sleep(3)
        print(f'{self.name} is over')

t = Myclass('jason')
t.start()
print('主线程')

线程对象的其他方法

from threading import Thread, active_count, current_thread
def test(name):
    print(f'{name} is running')
    print(current_thread().name)
    time.sleep(2)
    print(f'{name} is over')

t = Thread(target=test, args=('jason',))
t.start()
print(current_thread().name)
t.join()  # 等待子线程执行完再执行主线程(和进程的join一样)
print('主线程')

定义

随着守护线程的主线程结束，子线程也会立即关闭, 所以主线程需要等待里面所有非守护线程的结束才能结束

开启方式和上面的守护进程一样，在线程的start开启前，加入线程名.dameo = True 即可开启该线程的守护线程

小练习

下面的代码的打印顺序是如何的:

from threading import Thread
from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(3)
    print("end123")
def bar():
    print(456)
    time.sleep(1)
    print("end456")
if __name__ == '__main__':
    t1=Thread(target=foo)
    t2=Thread(target=bar)
    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

from threading import Thread

money = 100

def test():
    global money
    money = 999

t = Thread(target=test)
t.start()
t.join()
print(money)

和进程互斥锁一样，都是为了解决并发带来的修改同一数据时，数据错乱的情况，虽然减少了效率但是增加了数据的安全性。

加锁

from threading import Thread, Lock
import time

num = 100

def test():
    locked.acquire()  # 放置锁
    global num
    # 先获取num的数值
    tmp = num
    # 模拟延迟效果
    time.sleep(0.05)
    # 修改数值
    tmp -= 1
    num = tmp
    locked.release()  # 解除锁

t_list = []
locked = Lock()  # 生成锁
for i in range(100):
    t = Thread(target=test)
    t.start()
    t_list.append(t)
# 确保所有子线程全部结束
for t in t_list:
    t.join()
print(num)