python的多线程原来可以这样解

多线程

多线程类似于同时执行多个不同程序，多线程运行有如下优点：

使用线程可以把占据长时间的程序中的任务放到后台去处理。
用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。
程序的运行速度可能加快。
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。

创建线程

一个进程里面必然有一个主线程。

创建线程的两种方法
继承Thread类，并重写它的run()方法
import threading
import time
cLass MyThread(threading.Thread):
def__ init__ (seLf, n):
super (MyThread, seLf).__ init__()
self.n = n
def run(self):
print('以类的方式创建多线程'，self.n)
time.sleep(3)
r1 = MyThread(1)
r2 = MyThread(2)
r1.start()
r2.start()
调用threading库的Thread类
import threading
import time
def test(x):
   print(x)
   time.sleep(2)
if __name__=='__main__':
   t1 = threading.Thread(target=test, args=(1,))  
   t2 = threading.Thread(target=test, args=(2,))
   t1.start()
   t2.start()

守护线程此类线程的特点是，当程序中主线程及所有非守护线程执行结束时，未执行完毕的守护线程也会随之消亡（进行死亡状态），程序将结束运行。

#守护线程
import threading
import time
def run(n):
   print('task',n)
   time.sleep(1)
   print('3s')
   time.sleep(1)
   print('2s')
   time.sleep(1)
   print('1s')
if __name__ == '__main__': #主线程
   t=threading.Thread(target=run,args=('t1',))
   t.setDaemon(True) #设置子线程为守护线程，守护主线程。主线程结束，子线程也立马结束。必须在start() 方法调用之前设置
   t.start()
   print('end')

线程锁

1.互斥锁

#互斥锁
import threading
def run():
   global x
   lock.acquire() #申请锁
   x+=1
   lock.release() #释放锁
if __name__=='__main__':
   x=0
   res=[]
   lock=threading.Lock() #实例化线程锁
   for i in range(100): #100个线程
       t=threading.Thread(target=run)
       t.start()
       res.append(t)
   for t in res:
       t.join()    
   print(x)
2.递归锁

import threading
def func(lock):
   global gl_num
   lock.acquire()
   gl_num += 1
   time.sleep(1)
   print(gl_num)
   lock.release()
if __name__ == '__main__':
   gl_num = 0
   lock = threading.RLock()
   for i in range(10):
      t = threading.Thread(target=func,args=(lock,))
      t.start()

练手：

import threading
import time  #导入时间模块

#线程一：输出当前的年月日时分秒
class myThread1(threading.Thread):
   def run(self):
       while (True):
           print(time.asctime(time.localtime(time.time())))#输出实时时间
           time.sleep(1)
#线程二：name每2秒打印输出4次结束
class myThread2(threading.Thread):#继承threading.Thread
   def __init__(self,name):#继承父类的方法实现继承threading.Thread      
       super(myThread2, self).__init__()#super方法调用父类
       self.name=name #实例化对象属性    
   def run(self):#重写Thread类中的run方法
       for i in range(4):#for循环打印4次
           print(self.name)          
           time.sleep(2)#打印一次delay两秒
if __name__ == '__main__':
   #创建线程1和线程2并传入参数
   x1 = myThread1()
   x2 = myThread2("张三")
   #开启线程
   x1.start()
   x2.start()

来源：https://blog.csdn.net/lijin111222/article/details/122388381