IOT python高级培训（三）

Python 多线程

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

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

Python中使用线程有两种方式：函数或者用类来包装线程对象。

函数式：调用thread模块中的start_new_thread()函数来产生新线程。

thread.start_new_thread ( function, args[, kwargs] )

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个tuple类型。
• kwargs - 可选参数。

多线程实例

"""
1.线程是最小单位
2.进程由线程构成
3.进程之间相互独立

"""
import time #时间函数
import threading#threading线程处理

def test(x):
    print(x)
    time.sleep(2)

t1=threading.Thread(target=test,args=(1,))#使用多线程函数实现同时工作
t2=threading.Thread(target=test,args=(2,))#使用多线程函数实现同时工作
test(1)
class MyThread(threading.Thread):#通过类实现多线程
    def __init__(self,n):
        self.n=n
    def run(self):
        print('以类的方式创建多线程',self.n)
        time.sleep(3)
r1=MyThread(1)
r2=MyThread(1)
r1.run()
r2.run()

多线程特性

import threading
import time


def run(x):
    print(f"线程{x}")
    time.sleep(2)
#print(time.time())#从1970年到现在走了多少秒

if __name__=='__main__':
#     for i in range(51):
#         t = threading.Thread(target=run,args=(i,))
#         t.start()
#     print(f"运行了{time.time() - start_time}")

# run(1)
#Tread(target=函数名称，args=参数用括号表示（1，）)
    start_time=time.time()
    #
    res=[]
    for i in range(50):
        t=threading.Thread(target=run,args=(i,))
        # t2=threading.Thread(target=run,args=(2,))
        t.setDaemon(True)
        t.start()
        res.append(t)
    print(threading.active_count())

#在多线程中使用join函数代替wait

    # for i in res:
    #     i.join()


    print(f"运行了{time.time() - start_time}")
    print(threading.current_thread())#打印处于什么线程

线程锁

#线程锁
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):
        t=threading.Thread(target=run)
        t.start()
        res.append(t)
    for t in res:
        t.join()
    print(x)
"""
x=5 16 17 x=6
"""

递归锁

import threading

#RLOCK
def run1():
    global x
    lock.acquire()#锁2
    x+=1
    lock.release()#锁2
    return x
def run2():
    global y
    lock.acquire()
    y += 1
    lock.release()
    return y
def run3():
    lock.acquire()#锁1
    res1=run1()
    res2=run2()
    lock.release()#锁1
    print(res1,res2)
if __name__ == '__main__':

    x=0
    y=0
    lock=threading.RLock()#解决嵌套锁在函数中无法出来的问题
    for i in range(50):
        t=threading.Thread(target=run3)
        t.start()
    while threading.active_count()!=1:
        print(f"正在运行{threading.active_count()}个线程")
    print("结束")