三十四、线程理论要点

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

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

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