Thread创建线程，Lock互斥锁

from threading import Thread,Lock
xx = Thread(target=函数名)
xx.start() #执行线程

5个线程一起执行

import threading
import time
def saySory():
    print("品爱的，我错了")
    time.sleep(1)
if __name__ == '__main__':
    for i in range(5):
        #创建线程执行
        t = threading.Thread(target=saySory)
        #开始执行
        t.start()

进程里面套线程
进程是资源分配的单位，线程是CPU调度的单位

主线程会等待所有子线程结束才结束

import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)
def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)
if __name__ == "__main__":
    print('---开始---')
    #主线程会等待所有子线程结束才结束
    t1 = threading.Thread(target = sing)
    t2 = threading.Thread(target = dance)

    t1.start()
    t2.start()
    print("---结束---")

类方法

1个线程执行

#单线程执行
import threading
import time
class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "线程名字：%s,%s"%(self.name,i)
            print(msg)
if __name__ == "__main__":
    t = MyThread()
    t.start()

5个线程执行执行一个方法

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            msg = "线程名字：%s，%s"%(self.name,i)
            print(msg)
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == "__main__":
    test()

多进程全局变量不共享
多线程全局变量是共享的

互斥锁
创建锁：mutex = threading.Lock()
锁定：mutex.acquire([blocking])
释放：mutex.release()
其中，锁定发放acquire可以有一个blocking参数

• 如果设定blocking为True，则当前线程堵塞，直到获取到这个锁为止(如果没有指定，那么默认为True)
• 如果设定blocking为False，则当前线程不会堵塞

互斥锁代码：

from threading import Thread,Lock
import time

g_num = 0
def work1():
    global g_num
    #这个线程和work2线程都在抢着，如果有一方成功的上锁
    #那么导致另外一方会堵塞(一直等待)到这个锁被解开为止
    #上锁
    mutex.acquire()
    for i in range(1000000):
        g_num += 1
    #执行完上面代码解锁
    mutex.release()
    print("work1:%d"%g_num)
def work2():
    global g_num
    #上锁
    mutex.acquire()
    for i in range(1000000):
        g_num += 1
    #解锁
    mutex.release()
    print("work2:%d"%g_num)
#创建一把互斥锁
mutex = Lock()
if __name__ == "__main__":
    t1 = Thread(target=work1)
    t2 = Thread(target=work2)
    t1.start()
    t2.start()

锁的好处：
确保了某段关键代码只能由一个线程从头到尾完整地执行
锁得坏处：
1.阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
2.由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁