三十四、线程理论要点

佚名 6年前 (2019-05-08) 随笔 364人围观抢沙发百度已收录

一、线程理论

1、什么是线程

进程：资源单位

线程：执行单位

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

注意：每一个进程中都会自带一个线程

拿一个工厂中车间里的流水线作比喻
进程比喻为车间
线程比喻为流水线
操作系统比喻为工厂

2、为什么要有线程

开一个进程:：申请内存空间 --->>> 耗时

将代码拷贝到申请的内存空间中 --->>> 耗时

开线程:：不需要申请内存空间

不需要拷贝代码

3、开线程的开销远远小于开进程的开销

二、创建线程的两种方式

1、方式一

from threading import Thread
import time

def task(name):
    print('%s is running' % name)
    time.sleep(1)
    print('%s is over' % name)


if __name__ == '__main__':
    t = Thread(target=task, args=('egon',))
    t.start()  # 开启线程的速度非常快，几乎代码执行完线程就已经开启
    print('主')
# 结果为
# egon is running
# 主
# egon is over

2、方式二

from threading import Thread
import time

class MyThread(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running' % self.name)
        time.sleep(1)
        print('%s is over' % self.name)

if __name__ == '__main__':
    t = MyThread('jason')
    t.start()
    print('主')

# 结果为
# jason is running
# 主
# jason is over

三、线程之间数据共享

from threading import Thread

x = 100

def task():
    global x
    x = 20
    print(x)

if __name__ == '__main__':
    t = Thread(target=task)   # 实例化一个对象
    t.start()
    t.join()
    print(x)
# 结果为 20

四、线程对象其他方法

from threading import Thread, current_thread, active_count
import os
import time
def task(name):
    print('%s is running' %name, os.getpid(), current_thread().name)
    time.sleep(2)
    print('%s is over' % name)
    
def info(name):
    print('%s is running' % name, os.getpid(), current_thread().name)
    time.sleep(2)
    print('%s is over' % name)
    
if __name__ == '__main__':
    t1 = Thread(target=task, args=('jerry',))
    t2 = Thread(target=info, args=('tom',))
    t1.start()
    t2.start()
    t1.join()

    print(active_count())          # 当前存活的线程数
    print(os.getpid())             # id号
    print(current_thread().name)   # 线程名字
# 结果为
# jerry is running 7448 Thread-1
# tom is running 7448 Thread-2
# jerry is over
# 2
# 7448
# MainThread
# tom is over

五、守护线程

主线程必须等待所有非守护线程的结束才能结束

from threading import Thread
import time

def task(name):
    print('%s is running' % name)
    time.sleep(1)
    print('%s is over ' % name)

if __name__ == '__main__':
    t = Thread(target=task, args=('jerry',))
    t.daemon = True   # t.daemon = True:  主进程运行完不会检查子进程的状态（是否执行完），直接结束进程；
    t.start()
    print('主')
# 结果为
# jerry is running
# 主

六、线程互斥锁

from threading import Thread, Lock
import time

mutex = Lock()     # 涉及到多个线程或者进程操作同一份数据的时候，通常都需要将并行、并发变成串行
                   # 虽然牺牲了效率，但是提升了数据的安全性
n = 50
def task():
    global n
    mutex.acquire()      
    tmp = n
    time.sleep(0.1)  # 模拟io延迟
    n = tmp - 1
    mutex.release()

t_list = []
for i in range(50):
    t = Thread(target=task)
    t.start()
    t_list.append(t)

for t in t_list:
    t.join()

print(n)
# 结果为0