26 python 初学（线程、同步锁、死锁和递归锁）

时间：2023-03-08 17:59:32
26 python 初学（线程、同步锁、死锁和递归锁）

参考博客： www.cnblogs.com/yuanchenqi/articles/5733873.html

并发：一段时间内做一些事情

并行：同时做多件事情

线程是操作系统能够进行运算调度的基本单位，一个线程就是一个指令集

IO 密集型任务或函数  计算密集型任务函数

t1 = threading.Thread( target=foo, args=( , ))

t1.start()

# _author: lily

# _date: 2019/1/29

import threading

import time

class MyThread(threading.Thread):

    def __init__(self, num):

        threading.Thread.__init__(self)

        self.num = num

    def run(self):   # 定义每个线程要运行的函数

        print('running on number %s' % self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start()
# _author: lily

# _date: 2019/1/28

import threading

import time

def music(func):

    for i in range(2):

        print('listening to music %s.%s' % (func, time.ctime()))

        time.sleep(1)

        print('end listening %s' % time.ctime())

def move(func):

    for i in range(2):

        print('watching at the %s.%s' % (func, time.ctime()))

        time.sleep(5)

        print('end watching %s' % time.ctime())

threads = []

t1 = threading.Thread(target=music, args=('七里香', ))

threads.append(t1)

t2 = threading.Thread(target=move, args=('阿甘正传', ))

threads.append(t2)

if __name__ == '__main__':

    for t in threads:

        t.start()

    print('all over %s' % time.ctime())

GIL: 全局解释器锁。 对于一个进程，在同一时刻，python解释器中只允许一个线程运行。

结论：在 python里，如果是 io 密集型，可以用多线程

计算密集型，改 C。

守护线程： t.setDaemon(True)  当主线程结束之后就认为程序执行完毕，不会等待 t 线程执行完毕。

得到当前线程：  print(threading.current_thread())

得到当前活着的线程： print(threading.active_count())

同步锁：

原因：1. 线程共享同一资源，且进行 IO 阻塞时，对资源的操作容易被覆盖

  1. 使用 join 就会造成船串行，失去了多线程的意义

使用：r = threading.Lock()

同步锁与GIL关系：

没有GIL ，使用同步锁，可以达到一样得效果。

# _author: lily

# _date: 2019/1/29

import time

import threading

num = 100

def add():

    global num

    # num -= 1

    r.acquire()

    temp = num

    # time.sleep(0.0000001)

    print('ok')

    num = temp - 1

    r.release()

thread_list = []

r = threading.Lock()

for i in range(100):

    t = threading.Thread(target=add)

    t.start()

    thread_list.append(t)

for thd in thread_list:

    thd.join()

print('final num: ', num)

线程死锁和递归锁：

lock = threading.Lock()

lock = threading.RLock（）

# _author: lily

# _date: 2019/1/29

import threading

import time

class MyThread(threading.Thread):

    def __init__(self, name):

        threading.Thread.__init__(self)

        self.name = name

    def run(self):

        self.do_a()

        self.do_b()

    def do_a(self):

        # lock_a.acquire()

        my_lock.acquire()

        print('do_a:  thread %s get lock A' % self.name)

        time.sleep(3)

        my_lock.acquire()

        print('do_a:  thread %s get lock B' % self.name)

        # lock_b.release()

        # lock_a.release()

        my_lock.release()

        my_lock.release()

    def do_b(self):

        # lock_b.acquire()

        my_lock.acquire()

        print('do_b:  thread %s get lock B' % self.name)

        time.sleep(2)

        # lock_a.acquire()

        my_lock.acquire()

        print('do_b:  thread %s get lock A' % self.name)

        # lock_a.release()

        # lock_b.release()

        my_lock.release()

        my_lock.release()

# lock_a = threading.Lock()

# lock_b = threading.Lock()

my_lock = threading.RLock()

thread_list = []

for i in range(5):

    t = MyThread(i)

    thread_list.append(t)

    t.start()

for t in thread_list:

    t.join()

相关文章