python-thread多线程通俗理解

本文用简单的案例让读者理解 thread线程。

什么是线程：线程也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

thread机制：1、在python中，主线程结束后，会默认等待子线程结束后，主线程才退出。而在C/C++中，主线程结束后会把子线程kill掉。

　　　　　　2、如在一个线程1中调用thread2.join()，则thread2结束后，线程1才会接着thread2.join()往后运行。

　　　　　　3、主线程A启动了子线程B，调用b.setDaemaon(True)，则主线程A结束时，会把子线程B也杀死。

　　　　　　4、print(len(threading.enumerate()))  查看线程数量

 

案例一：炒菜与打乒乓球同步进行（主线程加一个子线程）

import threading
import time

def func():
    for _ in range(5):
        print("线程1:打乒乓球")
        time.sleep(1)

if __name__ == '__main__':
    thread = threading.Thread(target=func)#创建子线程
    thread.start()
    for _ in range(5):
        print('线程2：炒菜')#主线程和子线程轮流获得cpu资源
        time.sleep(1)

案例二：炒股与打台球同步进行（主线程加两个子线程）

import threading
import time

def test1():
    for i in range(5):
        print("炒股...%d"%i)
        time.sleep(1)

def test2():
    for i in range(5):
        print("打台球...%d"%i)
        time.sleep(1)
        
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
t1.start()
t2.start()
#time.sleep(5)    #如果放开等待时间，“收货精彩人生”将在最后打印
print("收获精彩人生")

案例三：吵架与打擦边球同步进行（设置保护线程）

import threading
import time

def test():
    for i in range(5):
        print("子线程吵架:", i)
        time.sleep(1)

if __name__ == '__main__':
    t1 = threading.Thread(target=test)
    t1.setDaemon(True)# 设置线程保护
    t1.start()
    time.sleep(2)

    print("主线程打完擦边球后退出")
    exit()

 # 如果没有设置线程保护，即使主线程exit退出，子线程也会继续运行

 案例四：生于忧患死于安乐（.join()指定线程优先执行）

import threading
#定义线程要调用的方法，*add可接收多个以非关键字方式传入的参数
def action(*add):
    for arc in add:
        print(threading.current_thread().getName() +" "+ arc)#调用 getName() 方法获取当前执行该程序的线程名
#定义为线程方法传入的参数
my_tuple = ("苦其心志",\
            "劳其筋骨",\
            "饿其体肤",\
            "空乏其身")
thread = threading.Thread(target = action,args =my_tuple)
thread.start()
thread.join()  #指定线程优先执行完毕，完毕后才继续往下执行。

for i in range(5): #主线程执行如下语句
    print(threading.current_thread().getName() + " 增益其所不能")

案例五：一千万次的反复无常（同步锁lock）

import threading

num = 0
def add():
    lock.acquire()#如果不加锁，频繁线程切换会导致两个线程数据不同步，最终num的值不是0.
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()
def sub():
    lock.acquire()#如果不加锁，频繁线程切换会导致两个线程数据不同步，最终num的值不是0.
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()
    
if __name__ == "__main__":
    lock = threading.Lock()
    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)
    subThread01.start()
    subThread02.start()
    subThread01.join()
    subThread02.join()
    print("num result : %s" % num) #num为0

对于同步锁来说，一次acquire()必须对应一次release()，不能出现连续重复使用多次acquire()后再重复使用多次release()的操作，这样会引起死锁造成程序的阻塞，完全不动了。

 案例六：千千万万万万千千个日夜（同步锁lock自加自解）

import threading
num = 0

def add():
    with lock:
        # 自动加锁
        global num
        for i in range(10_000_000):
            num += 1
        # 自动解锁
def sub():
    with lock:
        # 自动加锁
        global num
        for i in range(10_000_000):
            num -= 1
        # 自动解锁

if __name__ == "__main__":
    lock = threading.Lock() # threading.Lock()对象中实现了enter__()与__exit()方法；换成递归锁.RLock有相同效果
    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()
    subThread01.join()
    subThread02.join()
    print("num result : %s" % num) # num返回0

 案例七：循序渐进，以免固步自封（递归锁RLock，避免死锁）

import threading

num = 0
def add():
    lock.acquire()
    lock.acquire()#如果是同步锁，连续两次acquire会发生死锁现象
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()
    lock.release()
def sub():
    lock.acquire()
    lock.acquire()
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()
    lock.release()

if __name__ == "__main__":
    lock = threading.RLock()
    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)
    subThread01.start()
    subThread02.start()
    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

总结多线程

优点：

1、进程之间不能共享内存，但线程之间共享内存非常容易；

2、操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此使用多线程来实现多任务并发；
缺点：

1、由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源，可以定义多个锁，当需要独占某一个资源时，任何一个锁都可以锁定这个资源，就好比你用不同的锁都可以把这个相同的门锁住一样。

2、如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期， 我们因此也称为“线程不安全”。

 

 

命由己造，福由己求。谢天谢地，不忘祖先，敬畏圣贤。