多任务——线程

线程

线程：是CPU调度的最小单位，一个进程里面至少有一个线程，通过时间片轮训方式进行的

线程之间共享全局变量

线程的特点：1.是一个轻型实体 2.独立调度和分派的基本单位    3.共享进程资源 4.可并发执行

线程执行顺序：当所有子线程执行完毕，主线程执行完毕

 

Python实现多线程的两种方式：

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用，通过threading模块可以创建线程

多线程实现多任务方式1

# 引入threading线程模块
import threading
import time


def download_music():
    """模拟下载歌曲，需要5秒钟下载完成"""
    for i in range(5):
        time.sleep(1)  # 休眠1秒
        print("---正在下载歌曲%d---" % i)


def play_music():
    """模拟播放歌曲，需要5秒钟下载完成"""
    for i in range(5):
        time.sleep(1)  # 休眠1秒
        print("---正在播放歌曲%d---" % i)


def main():
    # 创建线程对象t1
    # target: 指向新开启的线程要执行的代码
    t1 = threading.Thread(target=download_music)
    t2 = threading.Thread(target=play_music)

    t1.start()  # 启动线程，既然线程开始执行
    t2.start()


if __name__ == '__main__':
    main()

多线程实现多任务方式

import threading
import time


# 2. 自定义类，继承threading.Thread类
class MyThread(threading.Thread):
    def run(self):
        """把线程要执行的代码封装在该方法中"""
        # threading.current_thread().name ：取得运行该代码的线程的名称，即当前线程的名称
        for i in range(3):
            time.sleep(1)  # 休眠1秒，模拟耗时的操作
            # print(" run  当前线程的名称%s ---代码块%d" %(threading.current_thread().name,i))
            print(" run  当前线程的名称%s ---代码块%d" % (self.name, i))


if __name__ == '__main__':
    print(" main  当前线程的名称%s" % threading.current_thread().name)
    # 通过自定义的类创建线程对象
    t1 = MyThread()

    # 执行线程
    t1.start()

说明：

　　　　python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，当该线程获得执行的机会时，就会调用run方法执行线程。

线程锁

GIL锁：全局解释器锁，是Cpython解释器下的python程序，它的存在导致同一时刻只有一个线程会执行解决解释器中多个线程竞争资源问题

互斥锁：当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import threading
import time
from threading import Lock,Thread

# 全局变量
num=0
mutex_lock=Lock()  #互斥锁

def work(loop):
    global num
    for i in range(loop):
        # 加锁
        mutex_lock.acquire()
        temp=num
        num=temp+1

        # 释放锁
        mutex_lock.release()
    print("in work ",num )

def work2(loop):
    global num
    for i in range(loop):
        mutex_lock.acquire()
        temp =num
        num=temp+1
        mutex_lock.release()
    print("in owrk",num)

if __name__ == '__main__':

    # 创建子线程
    t1=Thread(target=work,args=(10000,))
    t2=Thread(target=work2,args=(10000,))
    # 执行子线程
    t1.start()
    t2.start()
    # 主线程执行，表示子线程没有执行完，则主线程休眠1秒
    while len(threading.enumerate())!=1:
        time.sleep(1)
    print("2个子线程对同一个全局变成操作之后的最终结果为：%s"%num)

结果如下：