36 守护进程、守护线程、锁

守护进程随着主进程代码的执行结束而结束
守护线程会在主线程结束之后等待其他子线程的结束才结束

import time
from threading import Thread
def func1():
    while True:
        print('*'*10)
        time.sleep(1)
def func2():
    print('in func2')
    time.sleep(5)

t = Thread(target=func1,)
t.daemon = True
t.start()
t2 = Thread(target=func2,)
t2.start()
t2.join()
print('主线程')

主进程在其代码结束后就已经运行完毕了(守护进程在此时就会被回收)，然后主进程会一直等非守护的子进程都运行玩毕后回收子进程的资源(否则会产生僵尸进程)，才会结束。
主线程在其它非守护多线程运行完毕后才算运行完毕(守护线程在此时就被回收)。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须要保证非守护线程都运行完毕后才能结束。

锁

GIL锁，是锁的线程。

from threading import Lock,Thread
import time

def func():
    global n
    tem = n
    time.sleep(2)
    n = tem-1
n = 10
t_list = []
for i in range(10):
    t = Thread(target=func)
    t.start()
    t_list.append(t)
for i in t_list:
    i.join()
print(n)

输出：
在这里插入图片描述
十个线程都去取n的值，几乎同时取到n的值为10，接下来10个线程分别对自己取到的n值进行减一操作。

加锁

from threading import Lock,Thread
import time

def func(lock):
    global n
    lock.acquire()
    tem = n
    time.sleep(2)
    n = tem-1
    lock.release()
    print(n)
n = 10
t_list = []
lock = Lock()
for i in range(10):
    t = Thread(target=func,args=(lock,))
    t.start()
    t_list.append(t)
for i in t_list:
    i.join()

输出：
在这里插入图片描述
科学家吃面问题

from threading import Lock, Thread
import time

noodle_lock = Lock()	#互斥锁
fork_lock = Lock()


def eat1(name):
    noodle_lock.acquire()
    print('%s take the noodles' % name)
    fork_lock.acquire()
    print('%s take the fork' % name)
    print('%s eat the noodles' % name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print('%s take the fork' % name)
    time.sleep(1)
    noodle_lock.acquire()
    print('%s take the noodles' % name)
    print('%s eat the noodles' % name)
    noodle_lock.release()
    fork_lock.release()

Thread(target=eat1,args=('zhangsan',)).start()
Thread(target=eat2,args=('lisi',)).start()
Thread(target=eat1,args=('wangwu',)).start()
Thread(target=eat2,args=('123',)).start()

输出：
在这里插入图片描述
上述输出结果会发生阻塞。

递归锁，在同一个线程中，可以被多次require()

from threading import RLock,Thread   # 递归锁
import time
fork_lock = noodle_lock  = RLock()   # 一个钥匙串上的两把钥匙
def eat1(name):
    noodle_lock.acquire()
    print('%s take the noodles' % name)
    fork_lock.acquire()
    print('%s take the fork' % name)
    print('%s eat the noodles' % name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print('%s take the fork' % name)
    time.sleep(1)
    noodle_lock.acquire()
    print('%s take the noodles' % name)
    print('%s eat the noodles' % name)
    noodle_lock.release()
    fork_lock.release()

Thread(target=eat1,args=('zhangsan',)).start()
Thread(target=eat2,args=('lisi',)).start()
Thread(target=eat1,args=('wangwu',)).start()
Thread(target=eat2,args=('123',)).start()

输出：
在这里插入图片描述

36 守护进程、守护线程、锁

锁

猜你喜欢