Pthon - 线程管理

# 同一时间内执行多个任务
# 多任务执行的方式
# 并发:在一段时间内交替去执行任务
# 并行：指的是任务数小于等于cpu核数时，任务真的是一起执行的。

# 线程 cpu调试的基本单位 ，是程序执行的最小单位
# 每个进程至少都有一个线程（这个线程就是主线程）。
# 程序启动默认会有一个主线程

# 程序员自己创建的线程称为子线程，多线程可以完成多任务。

# 单线程
# import time
# def speak():
#     print('老师上周没来讲课')
#     time.sleep(2)
#     print('结果同学们都玩去了')
#
# def dance():
#     print('老师很伤心')
#     time.sleep(2)
#     print('跳个舞来挽救')
#
# if __name__ == '__main__':   #  条件满足时，程序直接运行
#     speak()
#     dance()

# 多线程
# 导入模块 import threading    Thread类----线程类
# Thread类参数：
# group:线程组
# target:执行的目标任务名
# args:以元组方式给执行任务来传参
# kwargs :以字典给执行任务传参  key = value
# name:线程名

# 步骤 ：
# 1.导入模块
# 2.创建子线程 Thread(target=func,args=(,),……)
# 3.设置守护线程 setDaemon  # 主线程执行完了，子线程也会跟着结束
# 4.启动子线程 start()
# 5.阻塞主线程join()  t1.join()

import time
import threading

t1 = time.time()  # 时间戳
def dance(name):
    print('%s在跳鬼步舞'% name)
    time.sleep(1)

if __name__ == '__main__':
    for i in range(4):
        # 创建子线程
        t = threading.Thread(target=dance,args=('欧阳同学',))  #逗号不能省略，是元组形式
        # 启动线程
        t.start()
t2 = time.time()
print('执行时间是：',t2-t1)

# 多线程并发的操作
# 从上例可知，并发的优势，在有等待的任务执行时，能够切换到其他线程执行，提高执行效率


import time
from threading import Thread

def funa():
    print('学习')
    time.sleep(2)
    print('是黎明前的黑暗')

def funb():
    print('来这里')
    time.sleep(2)
    print('面包票子朋友都会有的')

if __name__ == '__main__':
    # 创建线程
    f1 = Thread(target=funa)
    f2 = Thread(target=funb)

    # 设置守护线程————主线程执行完了，子线程也会跟着结束
    f1.setDaemon(True)
    f2.setDaemon(True)

    # 启动线程
    f1.start()
    f1.join()   # f1执行完再执行主线程下面的代码(等待f1执行完再执行下面的） 我等你
    f2.start()
    f2.join()

    # 修改名字
    f1.setName('线程1')
    f2.setName('线程2')

    #获取名字
    print(f1.getName())
    print(f2.getName())

    print('这是主线程，哈哈')

# 应用场景：IO密集型   多线程并发
# 定义一个线程类
# 1）继承Thread
# 2) 重构run方法（名称必须是run)
# 3)启动线程start   默认会调用 run方法

from threading import Thread
import time

class Ourthread(Thread): # 继承Thread类
    # 重构run方法，规定就是用run这个名字，表示线程活动的方法
    def run(self):
        print('重温对象')
        time.sleep(2)
        print('你们还找得着北吗')

if __name__ == '__main__':
    # 创建一个线程实例
    t1 = Ourthread()
    # 启动线程    start 会默认去调用run方法
    t1.start()

# 线程之间执行是无序的，它是由cpu调试来决定的。cpu调试哪个线程，哪个线程就先执行，没有调试的线程就不能够执行。
import threading
import time
def task():
    time.sleep(1)
    print(f'当前线程：{threading.current_thread().name}\n',end='')  # 获取当前线程名

if __name__ == '__main__':
    for i in range(5):
        t = threading.Thread(target=task)
        t.start()

from  threading import Thread
import time
list1 = []   #  全局变量

# 写数据
def writedata():
    for i in range(5):
        list1.append(i)
        time.sleep(0.2)
    print(f'写入的数据：{list1}\n',end='')

# 读数据
def readdata():
    print(f'读取的数据：{list1}\n',end='')

if __name__ == '__main__':
    # 创建写入数据的线程
    wd = Thread(target=writedata)
    # 创建读取数据的线程
    rd = Thread(target=readdata)

    # 启动线程
    wd.start()
    wd.join()
    rd.start()
    print('哈哈哈哈……')

from threading import Thread
a = 0
b = 1000000

def sum1():
    for i in range(b):
        global a
        a += 1
    print(f'第一次：{a}\n',end='')
# sum1()

def sum2():
    for i in range(b):
        global a
        a += 1
    print(f'第二次：{a}\n', end='')
# sum2()

if  __name__ == '__main__':
    # 创建线程
    t1 = Thread(target=sum1)
    t2 = Thread(target=sum2)

    # 启动线程
    t1.start()
    # t1.join()
    t2.start()

# 效果：按顺序执行    我等你执行完我（主线程）再执行

# 解决资源竞争的两种方法：1.线程同步join  2.互斥锁
# 互斥锁：成对出现的
# Lock 函数
# 加锁 acquire  # 释放锁release
from threading import Thread,Lock
a = 0
b = 1000000
# 创建锁
lock = Lock()
def sum1():
    lock.acquire()  # 加锁
    for i in range(b):
        global a
        a += 1
    print(f'第一次：{a}\n',end='')
    lock.release()    # 解锁

def sum2():
    lock.acquire()
    for i in range(b):
        global a
        a += 1
    print(f'第二次：{a}\n', end='')
    lock.release()

if  __name__ == '__main__':
    # 创建线程
    t1 = Thread(target=sum1)
    t2 = Thread(target=sum2)

    # 启动线程
    t1.start()
    t2.start()