Python 并发编程

参考文献：https://gitee.com/wupeiqi/python_course

并发编程：提升代码执行的效率。原来需要 10 分钟执行，并发处理后可以加快到 1 分钟。

  • 初识进程和线程
  • 多线程开发
  • 线程安全
  • 线程锁

1.进程和线程：

线程，是计算机中可以被cpu调度的最小单元(真正在工作）。

进程，是计算机资源分配的最小单元（进程为线程提供资源）。

一个进程中可以有多个线程,同一个进程中的线程可以共享此进程中的资源。

以前我们开发的程序中所有的行为都只能通过串行的形式运行，排队逐一执行，前面未完成，后面也无法继续。例如：

import time

result = 0

for i in range(100000000):

    result += i

print(result)


import time

import requests

url_list = [

    ("东北F4模仿秀.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f570000bvbmace0gvch7lo53oog"),

    ("卡特扣篮.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f3e0000bv52fpn5t6p007e34q1g"),

    ("罗斯mvp.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg")

]

print(time.time())

for file_name, url in url_list:

    res = requests.get(url)

    with open(file_name, mode='wb') as f:

        f.write(res.content)

    print(file_name, time.time())

通过 进程 和 线程 都可以将 串行 的程序变为并发，对于上述示例来说就是同时下载三个视频，这样很短的时间内就可以下载完成。

1.1 GIL锁

GIL， 全局解释器锁（Global Interpreter Lock），是CPython解释器特有一个玩意，让一个进程中同一个时刻只能有一个线程可以被CPU调用。

如果程序想利用 计算机的多核优势，让CPU同时处理一些任务，适合用多进程开发（即使资源开销大）。

如果程序不利用 计算机的多核优势，适合用多线程开发。

常见的程序开发中，计算操作需要使用CPU多核优势，IO操作不需要利用CPU的多核优势，所以，就有这一句话：

  • 计算密集型，用多进程，例如：大量的数据计算【累加计算示例】。
  • IO密集型，用多线程，例如：文件读写、网络数据传输【下载抖音视频示例】。

累加计算示例（计算密集型）：

  • 串行处理

    import time

start = time.time()

result = 0
    
for i in range(100000000):
    
    result += i
    
print(result)

end = time.time()

print("耗时：", end - start) # 耗时： 9.522780179977417

  • 多进程处理

    import time
    
import multiprocessing

def task(start, end, queue):
    
    result = 0
    
    for i in range(start, end):
    
        result += i
    
    queue.put(result)

if __name__ == '__main__':
    
    queue = multiprocessing.Queue()

    start_time = time.time()

    p1 = multiprocessing.Process(target=task, args=(0, 50000000, queue))
    
    p1.start()

    p2 = multiprocessing.Process(target=task, args=(50000000, 100000000, queue))
    
    p2.start()

    v1 = queue.get(block=True) #阻塞
    
    v2 = queue.get(block=True) #阻塞
    
    print(v1 + v2)

    end_time = time.time()

    print("耗时:", end_time - start_time) # 耗时: 2.6232550144195557

当然，在程序开发中 多线程 和 多进程 是可以结合使用，例如：创建2个进程（建议与CPU个数相同），每个进程中创建3个线程。

import multiprocessing

import threading

def thread_task():

    pass

def task(start, end):

    t1 = threading.Thread(target=thread_task)

    t1.start()

    t2 = threading.Thread(target=thread_task)

    t2.start()

    t3 = threading.Thread(target=thread_task)

    t3.start()

if __name__ == '__main__':

    p1 = multiprocessing.Process(target=task, args=(0, 50000000))

    p1.start()

    p2 = multiprocessing.Process(target=task, args=(50000000, 100000000))

    p2.start()

2.多线程开发

import threading

def task(arg):

    print(arg)

# 创建一个Thread对象(线程)， 并封装线程被CPU 调度时应该执行的任务和相关参数。

t=threading.Thread(target=task,args=('xxx',))# 注意此处函数的后面不需要添加()

'''当元组只有一个元素时需要添加一个额外的逗号，表示是数据类型是元组'''

# 线程准备就绪等待被CPU调度，代码继续向下执行

t.start()

print("继续执行。。。。")

线程的常见方法：

  • t.start()，当前线程准备就绪（等待CPU调度，具体时间是由CPU来决定）。

    import threading

loop = 10000000
    
number = 0

def _add(count):
    
    global number
    
    for i in range(count):
    
        number += 1

t = threading.Thread(target=_add,args=(loop,))
    
t.start()

print(number)

  • t.join()，等待当前线程的任务执行完毕后再向下继续执行。

    import threading

number = 0

def _add():
    
    global number
    
    for i in range(10000000):
    
        number += 1

t = threading.Thread(target=_add)
    
t.start()

t.join() # 主线程等待中...

print(number)
    

    import threading

number = 0

def _add():
    
    global number
    
    for i in range(10000000):
    
        number += 1

def _sub():
    
    global number
    
    for i in range(10000000):
    
        number -= 1

t1 = threading.Thread(target=_add)
    
t2 = threading.Thread(target=_sub)
    
t1.start()
    
t1.join()  # t1线程执行完毕,才继续往后走
    
t2.start()
    
t2.join()  # t2线程执行完毕,才继续往后走

print(number)


    import threading

loop = 10000000
    
number = 0

def _add(count):
    
    global number
    
    for i in range(count):
    
        number += 1

def _sub(count):
    
    global number
    
    for i in range(count):
    
        number -= 1

t1 = threading.Thread(target=_add, args=(loop,))
    
t2 = threading.Thread(target=_sub, args=(loop,))
    
t1.start()
    
t2.start()

t1.join()  # t1线程执行完毕,才继续往后走
    
t2.join()  # t2线程执行完毕,才继续往后走

print(number)

2.1 守护线程

  • t.setDaemon(布尔值) ，守护线程（必须放在start之前）

    • t.setDaemon(True)，设置为守护线程，主线程执行完毕后，子线程也自动关闭。
    • t.setDaemon(False)，设置为非守护线程，主线程等待子线程，子线程执行完毕后，主线程才结束。（默认）
    import threading
    
import time

def task(arg):
    
    time.sleep(5)
    
    print('任务')

t = threading.Thread(target=task, args=(11,))
    
t.setDaemon(True) # True/False
    
'''
    
当设置为 True 的时候，主线程不会等待子线程的结束，继续向下执行，结束后会直接结束子线程。
    
设置为 False 的时候，主线程会等待子线程执行完毕，才继续向下执行。
    
'''
    
t.start()

print('END')

  • 线程名称的设置和获取

    import threading

def task(arg):
    
    # 获取当前执行此代码的线程
    
    name = threading.current_thread().getName()
    
    print(name)

# 创建10个线程。
    
for i in range(10):
    
    t = threading.Thread(target=task, args=(11,))
    
    t.setName('日魔-{}'.format(i))# 设置线程的名字
    
    t.start()# 将线程设置为待调度状态

  • 自定义线程类，直接将线程需要做的事写到run方法中。

    import threading

class MyThread(threading.Thread):
    
    def run(self):
    
        print('执行此线程', self._args)

t = MyThread(args=(100,))
    
t.start()
    

    import requests
    
import threading

class DouYinThread(threading.Thread):
    
    def run(self):
    
        file_name, video_url = self._args
    
        res = requests.get(video_url)
    
        with open(file_name, mode='wb') as f:
    
            f.write(res.content)

url_list = [
    
    ("东北F4模仿秀.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f570000bvbmace0gvch7lo53oog"),
    
    ("卡特扣篮.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f3e0000bv52fpn5t6p007e34q1g"),
    
    ("罗斯mvp.mp4", "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg")
    
]
    
for item in url_list:
    
    t = DouYinThread(args=(item[0], item[1]))
    
    t.start()

3.线程安全

一个进程中可以有多个线程，且线程共享所有进程中的资源。

多个线程同时去操作一个"东西"，可能会存在数据混乱的情况，例如：

  • 示例1: 某个数加减 10000000 次

    import threading

loop = 10000000
    
number = 0

def _add(count):
    
    global number
    
    for i in range(count):
    
        number += 1

def _sub(count):
    
    global number
    
    for i in range(count):
    
        number -= 1

t1 = threading.Thread(target=_add, args=(loop,))
    
t2 = threading.Thread(target=_sub, args=(loop,))
    
t1.start()
    
t2.start()

t1.join()  # t1线程执行完毕,才继续往后走
    
t2.join()  # t2线程执行完毕,才继续往后走

print(number)

# 2755 出现线程安全问题，结果不唯一
    

    import threading

lock_object = threading.RLock()# 设置锁对象。

loop = 10000000
    
number = 0

def _add(count):
    
    lock_object.acquire() # 加锁
    
    global number # 使用global 声名全局变量
    
    for i in range(count):
    
        number += 1
    
    lock_object.release() # 释放锁

def _sub(count):
    
    lock_object.acquire() # 申请锁（等待）
    
    global number
    
    for i in range(count):
    
        number -= 1
    
    lock_object.release() # 释放锁

# 注意：两个方法应该使用同一把锁。使用不同的锁达不到效果，
    
t1 = threading.Thread(target=_add, args=(loop,))
    
t2 = threading.Thread(target=_sub, args=(loop,))
    
t1.start()
    
t2.start()

t1.join()  # t1线程执行完毕,才继续往后走
    
t2.join()  # t2线程执行完毕,才继续往后走

print(number)
    
# 0

  • 示例2：

    import threading

num = 0

def task():
    
    global num
    
    for i in range(1000000):
    
        num += 1
    
    print(num)

for i in range(2):
    
    t = threading.Thread(target=task)
    
    t.start()
    

    import threading

num = 0
    
lock_object = threading.RLock()

def task():
    
    print("开始")
    
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    
    global num
    
    for i in range(1000000):
    
        num += 1
    
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了
    
    print(num)

for i in range(2):
    
    t = threading.Thread(target=task)
    
    t.start()
    

    import threading

num = 0
    
lock_object = threading.RLock()

def task():
    
    print("开始")
    
    with lock_object: # 基于上下文管理，内部自动执行 acquire 和 release
    
        global num
    
        for i in range(1000000):
    
            num += 1
    
    print(num)

for i in range(2):
    
    t = threading.Thread(target=task)
    
    t.start()

注意：

在开发的过程中要注意有些操作默认都是 线程安全的（内部集成了锁的机制），我们在使用的时无需再通过锁再处理，例如：

import threading

data_list = []

lock_object = threading.RLock()

def task():

    print("开始")

    for i in range(1000000):

        data_list.append(i)

    print(len(data_list))

for i in range(2):

    t = threading.Thread(target=task)

    t.start()

所以，要多注意看一些开发文档中是否标明线程安全。

4. 线程锁

在程序中如果想要自己手动加锁，一般有两种：Lock 和 RLock。

  • Lock，同步锁。

    import threading

num = 0
    
lock_object = threading.Lock()

def task():
    
    print("开始")
    
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    
    global num
    
    for i in range(1000000):
    
        num += 1
    
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了

    print(num)

for i in range(2):
    
    t = threading.Thread(target=task)
    
    t.start()

  • RLock，递归锁。

    import threading

num = 0
    
lock_object = threading.RLock()

def task():
    
    print("开始")
    
    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。
    
    global num
    
    for i in range(1000000):
    
        num += 1
    
    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了
    
    print(num)

for i in range(2):
    
    t = threading.Thread(target=task)
    
    t.start()

RLock支持多次申请锁和多次释放；Lock不支持。例如：

import threading

import time

lock_object = threading.RLock()

def task():

    print("开始")

    lock_object.acquire()

    lock_object.acquire()

    print(123)

    lock_object.release()

    lock_object.release()

for i in range(3):

    t = threading.Thread(target=task)

    t.start()


import threading

lock = threading.RLock()

# 程序员A开发了一个函数，函数可以被其他开发者调用，内部需要基于锁保证数据安全。

def func():

	with lock:

		pass

# 程序员B开发了一个函数，可以直接调用这个函数。

def run():

    print("其他功能")

    func() # 调用程序员A写的func函数，内部用到了锁。

    print("其他功能")

# 程序员C开发了一个函数，自己需要加锁，同时也需要调用func函数。

def process():

    with lock:

		print("其他功能")

        func() # ----------------> 此时就会出现多次锁的情况，只有RLock支持（Lock不支持）。

		print("其他功能")

5.死锁

死锁，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象。

import threading

num = 0

lock_object = threading.Lock()

def task():

    print("开始")

    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。

    lock_object.acquire()  # 第1个抵达的线程进入并上锁，其他线程就需要再此等待。

    global num

    for i in range(1000000):

        num += 1

    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了

    lock_object.release()  # 线程出去，并解开锁，其他线程就可以进入并执行了

    print(num)

for i in range(2):

    t = threading.Thread(target=task)

    t.start()


import threading

import time 

lock_1 = threading.Lock()

lock_2 = threading.Lock()

'''

两个线程都有一个锁却都要获得对方的锁，产生了死锁现象

'''

def task1():

    lock_1.acquire()

    time.sleep(1)

    lock_2.acquire()

    print(11)

    lock_2.release()

    print(111)

    lock_1.release()

    print(1111)

def task2():

    lock_2.acquire()

    time.sleep(1)

    lock_1.acquire()

    print(22)

    lock_1.release()

    print(222)

    lock_2.release()

    print(2222)

t1 = threading.Thread(target=task1)

t1.start()

t2 = threading.Thread(target=task2)

t2.start()

6.线程池

Python3中官方才正式提供线程池。

线程不是开的越多越好，开的多了可能会导致系统的性能更低了，例如：如下的代码是不推荐在项目开发中编写。

不建议：无限制的创建线程。

import threading

def task(video_url):

    pass

url_list = ["www.xxxx-{}.com".format(i) for i in range(30000)]

for url in url_list:

    t = threading.Thread(target=task, args=(url,))

    t.start()

# 这种每次都创建一个线程去操作，创建任务的太多，线程就会特别多，可能效率反倒降低了。

建议：使用线程池

示例1：

import time

from concurrent.futures import ThreadPoolExecutor

# pool = ThreadPoolExecutor(100)

# pool.submit(函数名,参数1，参数2，参数...)

def task(video_url,num):

    print("开始执行任务", video_url)

    time.sleep(5)

# 创建线程池，最多维护10个线程。

pool = ThreadPoolExecutor(10)

url_list = ["www.xxxx-{}.com".format(i) for i in range(300)]

for url in url_list:

    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。

    pool.submit(task, url,2)

print("END")

示例2：等待线程池的任务执行完毕。

import time

from concurrent.futures import ThreadPoolExecutor

def task(video_url):

    print("开始执行任务", video_url)

    time.sleep(5)

# 创建线程池，最多维护10个线程。

pool = ThreadPoolExecutor(10)

url_list = ["www.xxxx-{}.com".format(i) for i in range(300)]

for url in url_list:

    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。

    pool.submit(task, url)

print("执行中...")

pool.shutdown(True)  # 等待线程池中的任务执行完毕后，在继续执行

print('继续往下走')

示例3：任务执行完任务，再干点其他事。

import time

import random

from concurrent.futures import ThreadPoolExecutor, Future

def task(video_url):

    print("开始执行任务", video_url)

    time.sleep(2)

    return random.randint(0, 10)

def done(response):

    print("任务执行后的返回值", response.result())

# 创建线程池，最多维护10个线程。

pool = ThreadPoolExecutor(10)

url_list = ["www.xxxx-{}.com".format(i) for i in range(15)]

for url in url_list:

    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。

    future = pool.submit(task, url)

    future.add_done_callback(done) # 是子主线程执行，传入参数是函数。

# 可以做分工，例如：task专门下载，done专门将下载的数据写入本地文件。

示例4：最终统一获取结果。

import time

import random

from concurrent.futures import ThreadPoolExecutor,Future

def task(video_url):

    print("开始执行任务", video_url)

    time.sleep(2)

    return random.randint(0, 10)

# 创建线程池，最多维护10个线程。

pool = ThreadPoolExecutor(10)

future_list = []

url_list = ["www.xxxx-{}.com".format(i) for i in range(15)]

for url in url_list:

    # 在线程池中提交一个任务，线程池中如果有空闲线程，则分配一个线程去执行，执行完毕后再将线程交还给线程池；如果没有空闲线程，则等待。

    future = pool.submit(task, url)

    future_list.append(future)

pool.shutdown(True)

for fu in future_list:

    print(fu.result())

案例：基于线程池下载豆瓣图片。

26044585,Hush,https://hbimg.huabanimg.com/51d46dc32abe7ac7f83b94c67bb88cacc46869954f478-aP4Q3V

19318369,柒十一,https://hbimg.huabanimg.com/703fdb063bdc37b11033ef794f9b3a7adfa01fd21a6d1-wTFbnO

15529690,Law344,https://hbimg.huabanimg.com/b438d8c61ed2abf50ca94e00f257ca7a223e3b364b471-xrzoQd

18311394,Jennah·,https://hbimg.huabanimg.com/4edba1ed6a71797f52355aa1de5af961b85bf824cb71-px1nZz

18009711,可洛爱画画,https://hbimg.huabanimg.com/03331ef39b5c7687f5cc47dbcbafd974403c962ae88ce-Co8AUI

30574436,花姑凉~,https://hbimg.huabanimg.com/2f5b657edb9497ff8c41132e18000edb082d158c2404-8rYHbw

17740339,小巫師,https://hbimg.huabanimg.com/dbc6fd49f1915545cc42c1a1492a418dbaebd2c21bb9-9aDqgl

18741964,桐末tonmo,https://hbimg.huabanimg.com/b60cee303f62aaa592292f45a1ed8d5be9873b2ed5c-gAJehO

30535005,TANGZHIQI,https://hbimg.huabanimg.com/bbd08ee168d54665bf9b07899a5c4a4d6bc1eb8af77a4-8Gz3K1

31078743,你的老杨,https://hbimg.huabanimg.com/c46fbc3c9a01db37b8e786cbd7174bbd475e4cda220f4-F1u7MX

25519376,尺尺寸,https://hbimg.huabanimg.com/ee29ee198efb98f970e3dc2b24c40d89bfb6f911126b6-KGvKes

21113978,C-CLong,https://hbimg.huabanimg.com/7fa6b2a0d570e67246b34840a87d57c16a875dba9100-SXsSeY

24674102,szaa,https://hbimg.huabanimg.com/0716687b0df93e8c3a8e0925b6d2e4135449cd27597c4-gWdv24

30508507,爱起床的小灰灰,https://hbimg.huabanimg.com/4eafdbfa21b2f300a7becd8863f948e5e92ef789b5a5-1ozTKq

12593664,yokozen,https://hbimg.huabanimg.com/cd07bbaf052b752ed5c287602404ea719d7dd8161321b-cJtHss

16899164,一阵疯,https://hbimg.huabanimg.com/0940b557b28892658c3bcaf52f5ba8dc8402100e130b2-G966Uz

847937,卩丬My㊊伴er彎,https://hbimg.huabanimg.com/e2d6bb5bc8498c6f607492a8f96164aa2366b104e7a-kWaH68

31010628,慢慢即漫漫,https://hbimg.huabanimg.com/c4fb6718907a22f202e8dd14d52f0c369685e59cfea7-82FdsK

13438168,海贼玩跑跑,https://hbimg.huabanimg.com/1edae3ce6fe0f6e95b67b4f8b57c4cebf19c501b397e-BXwiW6

28593155,源稚生,https://hbimg.huabanimg.com/626cfd89ca4c10e6f875f3dfe1005331e4c0fd7fd429-9SeJeQ

28201821,合伙哼哼,https://hbimg.huabanimg.com/f59d4780531aa1892b80e0ec94d4ec78dcba08ff18c416-769X6a

28255146,漫步AAA,https://hbimg.huabanimg.com/3c034c520594e38353a039d7e7a5fd5e74fb53eb1086-KnpLaL

30537613,配䦹,https://hbimg.huabanimg.com/efd81d22c1b1a2de77a0e0d8e853282b83b6bbc590fd-y3d4GJ

22665880,日后必火,https://hbimg.huabanimg.com/69f0f959979a4fada9e9e55f565989544be88164d2b-INWbaF

16748980,keer521521,https://hbimg.huabanimg.com/654953460733026a7ef6e101404055627ad51784a95c-B6OFs4

30536510,“西辞”,https://hbimg.huabanimg.com/61cfffca6b2507bf51a507e8319d68a8b8c3a96968f-6IvMSk

30986577,艺成背锅王,https://hbimg.huabanimg.com/c381ecc43d6c69758a86a30ebf72976906ae6c53291f9-9zroHF

26409800,CsysADk7,https://hbimg.huabanimg.com/bf1d22092c2070d68ade012c588f2e410caaab1f58051-ahlgLm

30469116,18啊全阿,https://hbimg.huabanimg.com/654953460733026a7ef6e101404055627ad51784a95c-B6OFs4

17473505,椿の花,https://hbimg.huabanimg.com/0e38d810e5a24f91ebb251fd3aaaed8bb37655b14844c-pgNJBP

19165177,っ思忆゜♪,https://hbimg.huabanimg.com/4815ea0e4905d0f3bb82a654b481811dadbfe5ce2673-vMVr0B

16059616,格林熊丶,https://hbimg.huabanimg.com/8760a2b08d87e6ed4b7a9715b1a668176dbf84fec5b-jx14tZ

30734152,sCWVkJDG,https://hbimg.huabanimg.com/f31a5305d1b8717bbfb897723f267d316e58e7b7dc40-GD3e22

24019677,虚无本心,https://hbimg.huabanimg.com/6fdfa9834abe362e978b517275b06e7f0d5926aa650-N1xCXE

16670283,Y-雨后天空,https://hbimg.huabanimg.com/a3bbb0045b536fc27a6d2effa64a0d43f9f5193c177f-I2vHaI

21512483,汤姆2,https://hbimg.huabanimg.com/98cc50a61a7cc9b49a8af754ffb26bd15764a82f1133-AkiU7D

16441049,笑潇啸逍小鱼,https://hbimg.huabanimg.com/ae8a70cd85aff3a8587ff6578d5cf7620f3691df13e46-lmrIi9

24795603,⁢⁢⁢⁢⁢v,https://hbimg.huabanimg.com/a7183cc3a933aa129d7b3230bf1378fd8f5857846cc5-3tDtx3

29819152,妮玛士珍多,https://hbimg.huabanimg.com/ca4ecb573bf1ff0415c7a873d64470dedc465ea1213c6-RAkArS

19101282,陈勇敢,https://hbimg.huabanimg.com/ab6d04ebaff3176e3570139a65155856871241b58bc6-Qklj2E

28337572,爱意随风散,https://hbimg.huabanimg.com/117ad8b6eeda57a562ac6ab2861111a793ca3d1d5543-SjWlk2

17342758,幸运instant,https://hbimg.huabanimg.com/72b5f9042ec297ae57b83431123bc1c066cca90fa23-3MoJNj

18483372,Beau染,https://hbimg.huabanimg.com/077115cb622b1ff3907ec6932e1b575393d5aae720487-d1cdT9

22127102,栽花的小蜻蜓,https://hbimg.huabanimg.com/6c3cbf9f27e17898083186fc51985e43269018cc1e1df-QfOIBG

13802024,LoveHsu,https://hbimg.huabanimg.com/f720a15f8b49b86a7c1ee4951263a8dbecfe3e43d2d-GPEauV

22558931,白驹过隙丶梨花泪う,https://hbimg.huabanimg.com/e49e1341dfe5144da5c71bd15f1052ef07ba7a0e1296b-jfyfDJ

11762339,cojoy,https://hbimg.huabanimg.com/5b27f876d5d391e7c4889bc5e8ba214419eb72b56822-83gYmB

30711623,雪碧学长呀,https://hbimg.huabanimg.com/2c288a1535048b05537ba523b3fc9eacc1e81273212d1-nr8M4t

18906718,西霸王,https://hbimg.huabanimg.com/7b02ad5e01bd8c0a29817e362814666a7800831c154a6-AvBDaG

31037856,邵阳的小哥哥,https://hbimg.huabanimg.com/654953460733026a7ef6e101404055627ad51784a95c-B6OFs4

26830711,稳健谭,https://hbimg.huabanimg.com/51547ade3f0aef134e8d268cfd4ad61110925aefec8a-NKPEYX


import os

import requests

from concurrent.futures import ThreadPoolExecutor

def download(file_name, image_url):

    res = requests.get(

        url=image_url,

        headers={

            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"

        }

    )

    # 检查images目录是否存在？不存在，则创建images目录

    if not os.path.exists("images"):

        # 创建images目录

        os.makedirs("images")

    file_path = os.path.join("images", file_name)

    # 2.将图片的内容写入到文件

    with open(file_path, mode='wb') as img_object:

        img_object.write(res.content)

# 创建线程池，最多维护10个线程。

pool = ThreadPoolExecutor(10)

with open("mv.csv", mode='r', encoding='utf-8') as file_object:

    for line in file_object:

        nid, name, url = line.split(",")

        file_name = "{}.png".format(name)

        pool.submit(download, file_name, url)


import os

import requests

from concurrent.futures import ThreadPoolExecutor

def download(image_url):

    res = requests.get(

        url=image_url,

        headers={

            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"

        }

    )

    return res

def outer(file_name):

    def save(response):

        res = response.result()

        # 写入本地

        # # 检查images目录是否存在？不存在，则创建images目录

        if not os.path.exists("images"):

            # 创建images目录

            os.makedirs("images")

        file_path = os.path.join("images", file_name)

        # # 2.将图片的内容写入到文件

        with open(file_path, mode='wb') as img_object:

            img_object.write(res.content)

    return save

# 创建线程池，最多维护10个线程。

pool = ThreadPoolExecutor(10)

with open("mv.csv", mode='r', encoding='utf-8') as file_object:

    for line in file_object:

        nid, name, url = line.split(",")

        file_name = "{}.png".format(name)

        fur = pool.submit(download, url)

        fur.add_done_callback(outer(file_name))# 传入参数，可以使用闭包的形式。

7.单例模式（扩展）

面向对象 + 多线程相关的一个面试题（以后项目和源码中会用到）。

之前写一个类，每次执行 类() 都会实例化一个类的对象。

class Foo:

    pass

obj1 = Foo()

obj2 = Foo()

print(obj1,obj2)

以后开发会遇到单例模式，每次实例化类的对象时，都是最开始创建的那个对象，不再重复创建对象。

  • 简单的实现单例模式

    class Singleton:
    
    instance = None

    def __init__(self, name):
    
        self.name = name

    def __new__(cls, *args, **kwargs):
    
        # 返回空对象
    
        if cls.instance:
    
            return cls.instance
    
        cls.instance = object.__new__(cls)
    
        return cls.instance

obj1 = Singleton('alex')
    
obj2 = Singleton('SB')

print(obj1,obj2)

  • 多线程执行单例模式，有BUG

    import threading
    
import time

class Singleton:
    
    instance = None

    def __init__(self, name):
    
        self.name = name

    def __new__(cls, *args, **kwargs):
    
        if cls.instance:
    
            return cls.instance
    
        time.sleep(0.1)
    
        cls.instance = object.__new__(cls)
    
        return cls.instance

def task():
    
    obj = Singleton('x')
    
    print(obj)

for i in range(10):
    
    t = threading.Thread(target=task)
    
    t.start()

  • 加锁解决BUG

    import threading
    
import time
    
class Singleton:
    
    instance = None
    
    lock = threading.RLock()

    def __init__(self, name):
    
        self.name = name

    def __new__(cls, *args, **kwargs):
    
        with cls.lock:
    
            if cls.instance:
    
                return cls.instance
    
            time.sleep(0.1)
    
            cls.instance = object.__new__(cls)
    
        return cls.instance

def task():
    
    obj = Singleton('x')
    
    print(obj)

for i in range(10):
    
    t = threading.Thread(target=task)
    
    t.start()

  • 加判断，提升性能

    import threading
    
import time
    
class Singleton:
    
    instance = None
    
    lock = threading.RLock()

    def __init__(self, name):
    
        self.name = name

    def __new__(cls, *args, **kwargs):

        if cls.instance:
    
            return cls.instance
    
        with cls.lock:
    
            if cls.instance:
    
                return cls.instance
    
            time.sleep(0.1)
    
            cls.instance = object.__new__(cls)
    
        return cls.instance

def task():
    
    obj = Singleton('x')
    
    print(obj)

for i in range(10):
    
    t = threading.Thread(target=task)
    
    t.start()

# 执行1000行代码

data = Singleton('asdfasdf')
    
print(data)

本篇总结

  1. 进程和线程的区别
  2. 什么是GIL锁
  3. 多线程和线程池的使用。
  4. 线程安全 & 线程锁 & 死锁
  5. 单例模式

Python 并发编程（上）的更多相关文章

  1. 快速了解Python并发编程的工程实现(上)

    关于我 一个有思想的程序猿,终身学习实践者,目前在一个创业团队任team lead,技术栈涉及Android.Python.Java和Go,这个也是我们团队的主要技术栈. Github:https:/ ...

  2. Python并发编程__多进程

    Python并发编程_多进程 multiprocessing模块介绍 python中的多线程无法利用多核优势,如果想要充分地使用多核CPU的资源(os.cpu_count()查看),在python中大 ...

  3. Python并发编程之深入理解yield from语法（八）

    大家好,并发编程 进入第八篇. 直到上一篇,我们终于迎来了Python并发编程中,最高级.最重要.当然也是最难的知识点--协程. 当你看到这一篇的时候,请确保你对生成器的知识,有一定的了解.当然不了解 ...

  4. Python并发编程二（多线程、协程、IO模型）

    1.python并发编程之多线程(理论) 1.1线程概念 在传统操作系统中,每个进程有一个地址空间,而且默认就有一个控制线程 线程顾名思义,就是一条流水线工作的过程(流水线的工作需要电源,电源就相当于 ...

  5. Python并发编程一（多进程）

    1.背景知识(进程.多道技术) 顾名思义,进程即正在执行的一个过程.进程是对正在运行程序的一个抽象. 进程的概念起源于操作系统,是操作系统最核心的概念,也是操作系统提供的最古老也是最重要的抽象概念之一 ...

  6. 《转载》Python并发编程之线程池/进程池--concurrent.futures模块

    本文转载自Python并发编程之线程池/进程池--concurrent.futures模块 一.关于concurrent.futures模块 Python标准库为我们提供了threading和mult ...

  7. Python并发编程系列之多线程

    1 引言 上一篇博文详细总结了Python进程的用法,这一篇博文来所以说Python中线程的用法.实际上,程序的运行都是以线程为基本单位的,每一个进程中都至少有一个线程(主线程),线程又可以创建子线程 ...

  8. Python并发编程系列之多进程（multiprocessing）

    1 引言 本篇博文主要对Python中并发编程中的多进程相关内容展开详细介绍,Python进程主要在multiprocessing模块中,本博文以multiprocessing种Process类为中心 ...

  9. python并发编程&多线程（二）

    前导理论知识见:python并发编程&多线程(一) 一 threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性 官网链 ...

随机推荐

  1. lsof恢复误删文件

    用 lsof 恢复 误删除文件实验: 先模拟一个进程: [tiger@root:/home/tiger]$ echo "hello deletede" >> test. ...

  2. ORA-15081: failed to submit an I/O operation to a disk

    Problem: While restoring controlfile to test environment, from filesystem or tape environment after ...

  3. openstack horizon 学习(3) DataTable

    上一篇中粗略的讲了下openstack中horizon的dashboard和panel的添加,本打算在这章中对有关于pluggable settings中的配置做详细的总结,然放弃了这念头.原因是搞懂 ...

  4. java实现跳过证书校验

    /** * 跳过证书效验的sslcontext * @return * @throws Exception */ private static SSLContext createIgnoreVerif ...

  5. linux下core 相关设置

    1)core文件简介core文件其实就是内存的映像,当程序崩溃时,存储内存的相应信息,主用用于对程序进行调试.当程序崩溃时便会产生core文件,其实准确的应该说是core dump 文件,默认生成位置 ...

  6. 在CentOS 6.x/7.x上安装git

    方式一.yum安装 # yum info git Failed to set locale, defaulting to C Loaded plugins: fastestmirror Loading ...

  7. 入门 - k8s伸缩应用程序 （六）

    目标 使用 kubectl 伸缩应用程序. Scaling(伸缩)应用程序 在之前的文章中,我们创建了一个 Deployment,然后通过 服务 提供访问 Pod 的方式.我们发布的 Deployme ...

  8. Embedded Python应用小结

    转载请注明来源:https://www.cnblogs.com/hookjc/ (1)初始化Python脚本运行环境 Py_Initialize(); (2) 脚本的编译 bytecode = Py_ ...

  9. 猪齿鱼平台常用前端css实现方案

    居中 最常用的height + line-height,以及margin:0 auto的居中方式就不再阐述,以下介绍两种容错性高的实现方案. flex布局实现 ​ 猪齿鱼前端日常开发中,我们多以fle ...

  10. 帆软报表（finereport）JS实现点击参数面板按钮显示或隐藏数据

    当报表中列出数据太多时,想通过显示按钮隐藏明细数据只显示统计数据.如下图示例,那么该如何实现呢?本文以FineReport为例,来讲述JS如何实现点击参数面板按钮显示或隐藏数据. 打开报表 在参数面板 ...