并发编程-线程

一：并发和并行

并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
并行：指的是任务数小于等于cpu核数，即任务真的是一起执行

image.png
image.png

二：threading模块

2-1：Thread类

创建线程对象的参数：
    target：指定任务函数
    name：设置线程名
    args：给任务函数传参
    kwargs：给任务函数传参
    daemon：设置是否作为守护线程

2-2：方法

start：启动线程执行
join：设置主线程等待子线程执行

2-2-1:方法的使用

import time
from threading import Thread
def func1():
    for i in range(5):
        print("------正在做事情1-----")
        time.sleep(1)

def func2():
    for i in range(6):
        print("------正在做事情2-----")
        time.sleep(1)
st = time.time()
#创建一个线程对象
t1 = Thread(target=func1)
t2 = Thread(target = func2)

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

# 主线程等待t1执行完，再往下执行
t1.join()
# 主线程等待t2执行完，在往下执行
t2.join()

# 需求：主线程等待子线程执行完
et = time.time()
print(et-st)

image.png

2-3:守护线程

设置子线程守护主线程执行

2-3-1:守护线程，及传参

def func1(aa):
    for i in range(5):
        print("{}------正在做事情1-----".format(aa))
        time.sleep(1)


def func2(aaa):
    for i in range(6):
        print("{}------正在做事情2-----".format(aaa))
        time.sleep(1)


# 创建一个线程对象
t1 = Thread(target=func1,name="木森1",daemon=True,args=("张三",))
t2 = Thread(target=func2,name="木森2",daemon=True,kwargs={"aaa":"李四"})


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

time.sleep(2)
print("---主线程执行结束---")

image.png

三：线程锁（解决多线程共享全局变量）

线程之间共用同一块内存，因此线程可以共享全局变量，如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确。如下案例,a的预期结果应是200000，但实际结果与预期结果不符

from threading import Thread
a = 0
def work():
    global  a

    for i in range(100000):
        a += 1
    print("work执行完：a",a)

def work2():
    global  a

    for i in range(100000):
        a += 1
    print("work2执行完：a",a)

t1 = Thread(target=work)
t2 = Thread(target=work2 )
t1.start()
t2.start()
t1.join()
t2.join()
print("a:",a)

image.png

3-1：解决方案：Lock锁

控制线程的执行，避免同时获取数据，线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。互斥锁为资源引入的一个状态方法acquire():锁定/方法release():释放锁，待锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为”锁定“，其他线程不能更改直到该线程释放资源，将资源的状态变成”非锁定“，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

from threading import Thread,Lock
a = 0
# 实例化一个锁对象
lockA = Lock()

def work():
    global  a

    for i in range(100000):
        lockA.acquire()
        a += 1
        lockA.release()

    print("work执行完：a",a)

def work2():
    global  a

    for i in range(100000):
        lockA.acquire()
        a += 1
        lockA.release()

    print("work2执行完：a",a)

t1 = Thread(target=work)
t2 = Thread(target=work2 )
t1.start()
t2.start()
t1.join()
t2.join()

print("a:",a)

image.png

四：练习题

一个列表中有100个url地址,每个地址请求一次，请设计程序一个程序，
使用4个线程去发送这 100个请求（假设请求每个地址需要0.5秒，请求的代码用time.sleep(0.5)代替）,
计算一共需要多长时间计算出总耗时！

import time
from threading import Thread

url_list = [f"https://www.baidu.com-{i}" for i in range(100)]


def work():
    while url_list:
        url = url_list.pop()
        print(url)
        time.sleep(0.5)


def main():
    # 创建4个线程
    start_time = time.time()
    ts = []
    for i in range(4):
        t1 = Thread(target=work)
        t1.start()
        ts.append(t1)

    for t in ts:
        t.join()
    end_time = time.time()
    print('执行时间为：', end_time - start_time)

main()