23 多任务线程（一）

1. 程序中模拟多任务

1.1 定义函数的方式创建线程

调用模块import threading，利用该模块中的threading.Thread（）方法创建多线程
使得案例中，singe()与dance()函数可以同时执行

import threading
import time

def singe():

    for i in range(3):

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


def dance():
    for i in range(3):
        print('正在跳舞....')
        time.sleep(1)

def main():

    t1 = threading.Thread(target=singe)
    t2 = threading.Thread(target=dance)

    t1.start()
    t2.start()

if __name__ == '__main__':

    main()

1.2 继承Thread类创建线程

import threading

class Main(threading.Thread):
	#重新定义run（）方法，覆盖父类中的run（）方法
    def run(self):

        for i in range(5):

            print(i)


if __name__ == '__main__':
	# 实例化
    m = Main()
	# 创建和启动子线程
    m.start()  

2. 主线程和子线程的执行关系

• 主线程会等待子线程结束之后在结束
• 使用.join() ，则等待子线程结束之后，主线程才继续执行
• setDaemon() 守护线程，不会等待子线程结束，一旦主线程结束，整个程序结束
• 当调用Thread的时候，不会创建线程。
  当调用Thread创建出来的实例对象的start方法的时候，才会创建线程以及开始运行这个线程。

import threading

def demo():               #子线程

    for i in range(5):
        print('hello world')

        time.sleep(1)


if __name__ == '__main__':    #主线程

    t = threading.Thread(target=demo)    #非正真创建子线程，只是实例化对象
    # 守护线程 不会等待子线程结束
    #t.setDaemon(True)  # 当1被输出后，程序整个程序结束
    t.start() # 创建和启动线程都是通过t.start（）主线程会等待子线程结束之后 主线程在结束
    # join() 等待子线程结束之后，主线程才继续执行
    #t.join()  结果：输出5个‘hello world后，再输出1’
    
    print(1)

3. 查看线程数量

• threading.enumerate() 查看当前线程的数量

# lst = ['a','b','c']
#
# for index,i in enumerate(lst):  
 enumerate（）方法会遍历出两个值，分别是索引值下标，索引值
#
#     print(i,index)
#     # print(type(i))
-------------------------------------------

import threading

import time
def demo1():

    for i in range(5):

        print('demo1--%d'%i)
        time.sleep(1)


def demo2():

    for i in range(10):
        print('demo2--%d' % i)
        time.sleep(1)


def main():

    t1 = threading.Thread(target=demo1,name = 'demo1')
    t2 = threading.Thread(target=demo2,name = 'demo2')

    t1.start()
    t2.start()

    while True:


        print(threading.enumerate())

        if len(threading.enumerate()) <= 1:
            break

        time.sleep(1)

if __name__ == '__main__':

    main()

4. 线程间的通信(多线程共享全局变量)

import threading
import time

# 线程间是共享的全局变量，进程不共享全局变量
num = 100

# num = [11,22]  列表一样可以

def demo1(nums):

    global num

    num += 1

    # num.append(nums)
    
    # print('demo1--%s'% str(num))


def demo2():

    #print('demo2--%s' % str(num))
    print(num)

def main():

    t1 = threading.Thread(target = demo1,args=(33,))
    t2 = threading.Thread(target = demo2)


    t1.start()

    time.sleep(1) # 保证demo1先执行

    t2.start()

    print('main-num=%s'% num)

输出结果：
demo2打印出101
主线程打印出main-num=101