2019-06-16线程

2019-06-17 本文已影响0人 hcc_9bf4

多任务，多个任务同时进行，多进程，多线程
=======》几个函数同时进行。。。。。之前未学习之前代码都是一步一步进行。。。。。
sublime,录屏，vnc服务器同时在一个电脑打开---》多线程
word里编辑，检查（多线程）
qq里可以语音，可以视频，可以发送消息（多线程）
进程里包含线程

创建线程Thread

面向过程
创建：
t=threading.Thread(target=xxx,name=xxx,args=(xx,xxx))
taget为线程启动之后要执行的函数
name为线程的名字，在函数中可以通过threading.current_thread().name获取线程的名字
args:主线程向子线程传递参数
t.start() 启动线程
t.join() 让主线程等待子线程结束

本地示例过程

import threading
import time
def sing(a):
    print('线程为%s,接受过来的参数为%s' % (threading.current_thread().name ,a))
    for x in range(1,6):
        print("我在唱舞娘")
        time.sleep(1)
def dance(a):
    print('线程为%s,接受过来的参数为%s' % (threading.current_thread().name ,a))
    for x in range(1,6):
        print("我在跳钢管舞")
        time.sleep(1)
def main():
    a="孙悟空"
    #创建唱歌线程.线程名字name,参数a
    tsing=threading.Thread(target=sing,name="唱歌",args=(a,))#thread是一个类，创建一个对象
    #创建跳舞线程
    tdance=threading.Thread(target=dance,name="跳舞",args=(a,))
    #启动线程
    tsing.start()
    tdance.start()
    #这里是主线程在运行
    print("这里是主线程")
if __name__ == '__main__':
    main()

显示：

线程为唱歌,接受过来的参数为孙悟空
我在唱舞娘
线程为跳舞,接受过来的参数为孙悟空这里是主线程

我在跳钢管舞
我在跳钢管舞我在唱舞娘

我在跳钢管舞我在唱舞娘

我在跳钢管舞我在唱舞娘

我在唱舞娘我在跳钢管舞

[Finished in 5.1s]

主线程跑完了,子线程还没跑

import threading
import time
def sing(a):
    print('线程为%s,接受过来的参数为%s' % (threading.current_thread().name ,a))
    for x in range(1,6):
        print("我在唱舞娘")
        time.sleep(1)
def dance(a):
    print('线程为%s,接受过来的参数为%s' % (threading.current_thread().name ,a))
    for x in range(1,6):
        print("我在跳钢管舞")
        time.sleep(1)
def main():
    a="孙悟空"
    #创建唱歌线程.线程名字name,参数a
    tsing=threading.Thread(target=sing,name="唱歌",args=(a,))#thread是一个类，创建一个对象
    #创建跳舞线程
    tdance=threading.Thread(target=dance,name="跳舞",args=(a,))
    #启动线程
    tsing.start()
    tdance.start()
    #让主线程等待子线程结束之后结束
    tsing.join()
    tdance.join()
    #这里是主线程在运行
    print("这里是主线程")
if __name__ == '__main__':
    main()

显示：

线程为唱歌,接受过来的参数为孙悟空
我在唱舞娘
线程为跳舞,接受过来的参数为孙悟空
我在跳钢管舞
我在跳钢管舞我在唱舞娘

我在跳钢管舞我在唱舞娘

我在唱舞娘我在跳钢管舞

我在跳钢管舞我在唱舞娘

这里是主线程
[Finished in 5.1s]

面向对象
定义一个类，继承自threading.Thread,重写一个方法
run方法，需要线程名字，传递参数，重写构造方法，在重写构造方法的时候，一定要注意手动调用父类的构造方法-----》super().init()调用父类构造方法
示例代码：

import threading
import time

#写一个类，继承自threading.Thread
class SingThread(threading.Thread):
    def __init__(self,name,a):
        super().__init__()
        self.name=name
        self.a=a
    def run(self):
        print('线程名字是%s,接受的参数是%s' % (self.name,self.a))
        for x in range(1,6):
            print("我在唱七里香")
            time.sleep(1)
class DanceThread(threading.Thread):
    def __init__(self,name,a):
        super().__init__()
        self.name=name
        self.a=a
    def run(self):
        print('线程名字是%s,接受的参数是%s' % (self.name,self.a))
        for x in range(1,6):
            print("我在跳广场舞")
            time.sleep(1)

def main():
    #创建线程
    tsing=SingThread('sing','猪八戒')
    tdance=DanceThread('dance','猪悟能')

    #启动线程
    tsing.start()
    tdance.start()

    #让主线程等待结束
    tsing.join()
    tdance.join()

    print("主线程和子线程都结束")


if __name__ == '__main__':
    main()

显示：

线程名字是sing,接受的参数是猪八戒
我在唱七里香
线程名字是dance,接受的参数是猪悟能
我在跳广场舞
我在跳广场舞我在唱七里香

我在跳广场舞我在唱七里香

我在唱七里香
我在跳广场舞
我在跳广场舞我在唱七里香

主线程和子线程都结束
[Finished in 5.1s]

线程同步
线程之间共享全局变量，很容易发生数据的紊乱问题，这个时候要使用线程锁，抢，谁抢到，谁上锁之后，谁就先使用
创建锁
suo=threading.Lock()
上锁
suo.acquire()
释放锁
suo.release()
队列(queue)
下载线程
解析线程，通过队列进行交互
q=Queue(5)#创建队列
q.put('xxx') 如果队列满，程序卡在这里等待
q.put('xxx',False)#如果队列满，程序直接报错
q.put('xxx',True,3)如果队列满，程序等待3s再报错
获取数据
q.get() 如果队列为空，程序卡在这里等待
q.get(False) 如果队列为空，程序直接报错
q.get(True, 3)如果队列为空，程序等待3s报错

q.empty()判断队列是否为空
q.full()判断队列是否已满
q.qsize() 获取队列长度

小测代码：

from queue import Queue

#创建队列
q=Queue(5)
print(q.empty())
#存储数据
q.put('科比')
q.put('勒布朗')
q.put('JR')
q.put('汤普森')
q.put('LOVE')
print(q.qsize())
print(q.full())
# q.put('乔治布尔',True,3)
# print(q)
#取数据
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())

显示代码：

True #显示为空队列
5 #队列长度为5
True #队列已满
科比
勒布朗
JR
汤普森
LOVE
[Finished in 0.1s]

2019-06-16线程

猜你喜欢

热点阅读