python的多线程（简单实现；共享全局变量；自定义线程名；互斥锁和死锁）

1多线程概念：多线程指的是从软件或者硬件上实现多个线程并发执行的技术，通俗上说就是同时执行的多个任务。（同时执行多个任务就是并行，这是个伪概念，因为pycharm的运行机制决定了不可能真正实现并行）

2简单实现一个多线程：

#并发  ：先写一个字吃两口苹果在写几个字再吃几口苹果
#并行  ：一边吃苹果一边写作业
#进程  ：
#线程 ：
#协程  ：
import threading
import time
def Sing():
    for i in range(5):

        print('正在唱歌')
        time.sleep(1)

def Dance():
    for j in range(5):
        print('正在跳舞')
        time.sleep(1)
if __name__ == '__main__':
    print('调用前：',threading.enumerate())    #threading.enumerate() ：查看线程
    t = threading.Thread(target=Sing)
    t2 = threading.Thread(target=Dance)
    print('创建线程后：',threading.enumerate())
    t.start()
    t2.start()
    print('调用后：',threading.enumerate())

3共享全局变量多线程，在同一进程下的多个线程里全局变量是共享的：

import threading

#全局变量
num = 0

# 任务一：加1
def work1(number):
    global num
    for i in range(number):
        num += 1
    print('此时num等于',num)
# 任务二：加1
def work2(number):
    global num
    for i in range(number):
        num += 1
    print('此时num等于',num)

if __name__ == '__main__':
    t1=threading.Thread(target=work1,args=(1000000,))
    t2=threading.Thread(target=work2,args=(1000000,))
    t1.start()
    t2.start()

4自定义线程名：

import threading
class MyThread(threading.Thread):

    def __init__(self,num):
        super(MyThread, self).__init__()    #引用父类初始化
        self.num = num


    def run(self):
        print('我是线程：%s'%self.num)

if __name__ == '__main__':
    mythread = MyThread(666)
    mythread.start()

5互斥锁和死锁：互斥锁是指锁住一个线程或进程执行，执行完后再执行下一个。
死锁是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

import threading

#全局变量
num = 0

# 任务一：加1
def work1(number):
    #上锁
    lock.acquire()
    global num
    for i in range(number):
        num += 1
    print('此时num等于',num)
    #解锁
    lock.release()
# 任务二：加1
def work2(number):
    lock.acquire()
    global num
    for i in range(number):
        num += 1
    print('此时num等于',num)
    lock.release()
#创建互斥锁
lock=threading.Lock()

if __name__ == '__main__':
    t1=threading.Thread(target=work1,args=(10000000,))
    t2=threading.Thread(target=work2,args=(10000000,))
    t1.start()
    t2.start()

lock.acquire(timeout=1) #死锁就是加一个溢出时间，超过时间就退出