【11.0】进程池和线程池

于 2024-01-23 14:29:00 发布
阅读量468 收藏 8
点赞数 8
CC 4.0 BY-SA版权
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Chimengmeng/article/details/135786011
博客围绕Python开发展开，先介绍TCP实现并发效果的原理，指出开设进程或线程会消耗资源。接着阐述池的概念，它能保证硬件安全并最大程度利用计算机。还详细讲解了线程池和进程池的语法、原理、优点及使用方法，包括任务提交方式、异步返回值等，最后给出相关模版。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【一】TCP实现并发的效果的原理

  • 每开设一个客户端，就会有一个服务端服务

【1】服务端

from socket import *
from threading import Thread


def server_create(IP, PORT):
    server = socket()

    server.bind((IP, PORT))

    server.listen(5)

    while True:
        conn, addr = server.accept()
        t = Thread(target=conn_communication, args=(conn,))


def conn_communication(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:
                break
            print(data.decode('utf8'))
            conn.send(data.upper())
        except Exception as e:
            print(e)
            break
    conn.close()


def main():
    IP = '127.0.0.1'
    PORT = 8086
    t = Thread(target=server_create, args=(IP, PORT,))
    t.start()


if __name__ == '__main__':
    main()

【2】客户端

from socket import *


def client_create(IP, PORT):
    client = socket()

    client.connect((IP, PORT))

    while True:
        word = b'hello world'
        client.send(word)

        msg = client.recv(1024)
        print(msg)


if __name__ == '__main__':
    IP = '127.0.0.1'
    PORT = 8086

    client_create(IP, PORT)

【3】小结

  • 无论是开设进程还是开设线程，都需要消耗资源
  • 只不过开始线程消耗的资源比开始进程相对少一些
  • 硬件的开发速度永远赶不上软件开发速度
  • 我们的宗旨是保证计算机硬件正常工作的情况下最大程度的利用它

【二】什么是池

  • 池是用来保证计算机硬件安全的情况下最大限度的利用计算机
  • 池降低了程序的运行效率，但是保证了计算机硬件的安全，从而保证程序的正常运行

【三】线程池

【1】语法

from concurrent.futures import ThreadPoolExecutor

# 默认开设当前计算机 cpu 个数五倍数的线程数
# 可以指定线程总数
pool = ThreadPoolExecutor(5)

【2】原理

  • 池子造出来后 里面固定存在五个线程
  • 这五个线程不会存在出现重复创建和销毁的过程

【3】优点

  • 避免了重复创建五个线程的资源开销

【4】使用方法

(0)任务的提交方式

  • 同步：提交任务之后原地等待任务的返回结果，期间不做任何事
  • 异步：提交任务之后不等待任务的返回结果，继续执行代码
    • 思考：返回结果如何获取？

(1)同步提交

from concurrent.futures import ThreadPoolExecutor
import time

# 构造线程池，指定线程总数
pool = ThreadPoolExecutor(5)


# 定义线程任务
def task(n):
    print(n)
    time.sleep(2)


# 向线程池中添加线程任务
def normal():
    pool.submit(task, 1)

    # 异步提交 - 先执行子线程再打印主线程
    print('this is a main task')

    # 1
    # this is a main task


if __name__ == '__main__':
    normal()

(2)异步提交

from concurrent.futures import ThreadPoolExecutor
import time

# 构造线程池，指定线程总数
pool = ThreadPoolExecutor(5)


# 定义线程任务
def task(n):
    print(n)
    time.sleep(2)


# 向线程池中添加线程任务
def normal():
    pool.submit(task, 1)

    # 异步提交 - 先执行子线程再打印主线程
    print('this is a main task')

    # 1
    # this is a main task


def many_steps():
    for i in range(20):
        pool.submit(task, i)
    print('this is a main task')


if __name__ == '__main__':
    many_steps()

    # 0
    # 1
    # 2
    # 3
    # 4
    # this is a main task
    # 先执行五个子线程，再回到主线程
    # 5
    # 6
    # 7
    # 8
    # 9
    # 10
    # 11
    # 12
    # 13
    # 14
    # 15
    # 16
    # 17
    # 18
    # 19

【5】异步返回值

(1)查看异步回调对象

from concurrent.futures import ThreadPoolExecutor
import time

# 构造线程池，指定线程总数
pool = ThreadPoolExecutor(5)


# 定义线程任务
def task(n):
    print(f"这是线程任务中的 n :>>>> {n}")
    time.sleep(2)
    return n * 2


def many_steps():
    for i in range(5):
        # 提交任务到线程池，并获取到返回值
        res = pool.submit(task, i)
        print(f'这是 pool的返回值:>>>>{res}')
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
        # <Future at 0x134d3fcd0 state=pending>
        print(f'这是 pool的返回值:>>>>{res.result()}')  # None
        # 程序由并发变成了串行
        # 返回的结果是 None ---> 任务的返回结果 ----> 拿到了异步提交的返回结果
        # res.result() ： 拿到的就是异步提交的任务的返回结果
    print('this is a main task')
    # 这是线程任务中的 n :>>>> 0这是 pool的返回值:>>>><Future at 0x104f36350 state=running>
    #
    # 这是 pool的返回值:>>>>0
    # 这是 pool的返回值:>>>><Future at 0x11747b460 state=pending>
    # 这是线程任务中的 n :>>>> 1
    # 这是 pool的返回值:>>>>2
    # 这是 pool的返回值:>>>><Future at 0x104f36350 state=pending>
    # 这是线程任务中的 n :>>>> 2
    # 这是 pool的返回值:>>>>4
    # 这是 pool的返回值:>>>><Future at 0x11747b160 state=pending>
    # 这是线程任务中的 n :>>>> 3
    # 这是 pool的返回值:>>>>6
    # 这是 pool的返回值:>>>><Future at 0x104f36350 state=pending>
    # 这是线程任务中的 n :>>>> 4
    # 这是 pool的返回值:>>>>8
    # this is a main task


if __name__ == '__main__':
    many_steps()

(2)调用异步回调对象

from concurrent.futures import ThreadPoolExecutor
import time

# 构造线程池，指定线程总数
pool = ThreadPoolExecutor(5)


# 定义线程任务
def task(n):
    print(f"这是线程任务中的 n :>>>> {n}")
    time.sleep(2)
    return n * 2


def many_steps():
    task_list = []
    for i in range(5):
        # 提交任务到线程池，并获取到返回值
        res = pool.submit(task, i)
        print(f'这是 pool的返回值:>>>>{res}')
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
        # <Future at 0x134d3fcd0 state=pending>
        task_list.append(res)

    for task_every in task_list:
        print(f'这是 pool的返回值:>>>>{task_every.result()}')  # None
        # 程序由变成了串行
        # res.result() ： 拿到的就是异步提交的任务的返回结果
        # 程序运行的结果是有序的
    print('this is a main task')
    # 这是线程任务中的 n :>>>> 0这是 pool的返回值:>>>><Future at 0x154e6bfa0 state=running>
    # 
    # 这是线程任务中的 n :>>>> 1
    # 这是 pool的返回值:>>>><Future at 0x15511bc10 state=running>
    # 这是线程任务中的 n :>>>> 2这是 pool的返回值:>>>><Future at 0x15511beb0 state=running>
    # 
    # 这是线程任务中的 n :>>>> 3
    # 这是 pool的返回值:>>>><Future at 0x1551401c0 state=running>
    # 这是线程任务中的 n :>>>> 4
    # 这是 pool的返回值:>>>><Future at 0x1551404c0 state=running>
    # 这是 pool的返回值:>>>>0
    # 这是 pool的返回值:>>>>2
    # 这是 pool的返回值:>>>>4
    # 这是 pool的返回值:>>>>6
    # 这是 pool的返回值:>>>>8
    # this is a main task


if __name__ == '__main__':
    many_steps()

【6】pool.shutdown()

  • 等待所有子线程结束后再打印程序运行结果
from concurrent.futures import ThreadPoolExecutor
import time

# 构造线程池，指定线程总数
pool = ThreadPoolExecutor(5)


# 定义线程任务
def task(n):
    print(f"这是线程任务中的 n :>>>> {n}")
    time.sleep(2)
    return n * 2


def many_steps():
    task_list = []
    for i in range(5):
        # 提交任务到线程池，并获取到返回值
        res = pool.submit(task, i)
        print(f'这是 pool的返回值:>>>>{res}')
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
        # <Future at 0x134d3fcd0 state=pending>
        task_list.append(res)

    # 关闭线程池 - 等待所有的线程池中的任务运行完毕
    pool.shutdown()

    for task_every in task_list:
        print(f'这是 pool的返回值:>>>>{task_every.result()}')  # None
        # 程序由变成了串行
        # res.result() ： 拿到的就是异步提交的任务的返回结果
        # 程序运行的结果是有序的
    print('this is a main task')
    # 这是线程任务中的 n :>>>> 0
    # 这是 pool的返回值:>>>><Future at 0x13a713fa0 state=running>
    # 这是线程任务中的 n :>>>> 1
    # 这是 pool的返回值:>>>><Future at 0x13a9c3c70 state=running>
    # 这是线程任务中的 n :>>>> 2
    # 这是 pool的返回值:>>>><Future at 0x13a9c3f10 state=running>
    # 这是线程任务中的 n :>>>> 3
    # 这是 pool的返回值:>>>><Future at 0x13a9ec220 state=running>
    # 这是线程任务中的 n :>>>> 4
    # 这是 pool的返回值:>>>><Future at 0x13a9ec520 state=running>
    # 这是 pool的返回值:>>>>0
    # 这是 pool的返回值:>>>>2
    # 这是 pool的返回值:>>>>4
    # 这是 pool的返回值:>>>>6
    # 这是 pool的返回值:>>>>8
    # this is a main task


if __name__ == '__main__':
    many_steps()

【四】进程池的使用

  • 开设进程的进程 ID 号不会发生改变
import os
from concurrent.futures import ProcessPoolExecutor
import time

# 构造进程池，指定进程总数
pool = ProcessPoolExecutor(5)


# 定义线程任务
def task(n):
    print(n, f'当前进程的进程号:>>>{os.getpid()}')
    print(f"这是线程任务中的 n :>>>> {n}")
    time.sleep(2)
    return n * 2


def many_steps():
    task_list = []
    for i in range(5):
        # 提交任务到进程池，并获取到返回值
        res = pool.submit(task, i)
        print(f'这是 pool的返回值:>>>>{res}')
        # 返回值是一个类对象 - result 方法 ----> 返回异步回调的结果
        # <Future at 0x134d3fcd0 state=pending>
        task_list.append(res)

    # 关闭进程池 - 等待所有的进程池中的任务运行完毕
    pool.shutdown()

    for task_every in task_list:
        print(f'这是 pool的返回值:>>>>{task_every.result()}')  # None
        # 程序由变成了串行
        # res.result() ： 拿到的就是异步提交的任务的返回结果
        # 程序运行的结果是有序的
        
    print('this is a main task')
    # 这是 pool的返回值:>>>><Future at 0x136434a30 state=running>
    # 这是 pool的返回值:>>>><Future at 0x136435630 state=running>
    # 这是 pool的返回值:>>>><Future at 0x136435810 state=pending>
    # 这是 pool的返回值:>>>><Future at 0x136435bd0 state=pending>
    # 这是 pool的返回值:>>>><Future at 0x136435ba0 state=pending>
    # 0 当前进程的进程号:>>>44758
    # 这是线程任务中的 n :>>>> 0
    # 1 当前进程的进程号:>>>44759
    # 这是线程任务中的 n :>>>> 1
    # 2 当前进程的进程号:>>>44756
    # 这是线程任务中的 n :>>>> 2
    # 3 当前进程的进程号:>>>44757
    # 这是线程任务中的 n :>>>> 3
    # 4 当前进程的进程号:>>>44760
    # 这是线程任务中的 n :>>>> 4
    # 这是 pool的返回值:>>>>0
    # 这是 pool的返回值:>>>>2
    # 这是 pool的返回值:>>>>4
    # 这是 pool的返回值:>>>>6
    # 这是 pool的返回值:>>>>8
    # this is a main task


if __name__ == '__main__':
    many_steps()

【五】异步回调函数

  • add_done_callback(call_back)

  • add_done_callback(call_back) 返回值正是我们的上面 pool的返回的结果

import os
from concurrent.futures import ProcessPoolExecutor
import time

# 构造进程池，指定进程总数
pool = ProcessPoolExecutor(5)


# 定义线程任务
def task(n):
    print(n, f'当前进程的进程号:>>>{os.getpid()}')
    print(f"这是线程任务中的 n :>>>> {n}")
    time.sleep(2)
    return n * 2


# 定义一个异步回调函数
def call_back(n):
    print(f'call_back>>>:{n}')


def many_steps():
    task_list = []
    for i in range(5):
        # 提交任务到进程池，并获取到返回值，添加一个异步回调函数
        res = pool.submit(task, i).add_done_callback(call_back)
        print(f'这是 pool的返回值:>>>>{res}')
        
    print('this is a main task')
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # this is a main task
    # 0 当前进程的进程号:>>>44878
    # 这是线程任务中的 n :>>>> 0
    # 1 当前进程的进程号:>>>44875
    # 这是线程任务中的 n :>>>> 1
    # 2 当前进程的进程号:>>>44876
    # 这是线程任务中的 n :>>>> 2
    # 3 当前进程的进程号:>>>44879
    # 这是线程任务中的 n :>>>> 3
    # 4 当前进程的进程号:>>>44877
    # 这是线程任务中的 n :>>>> 4
    # call_back>>>:<Future at 0x12ca38910 state=finished returned int>
    # call_back>>>:<Future at 0x12ca392d0 state=finished returned int>
    # call_back>>>:<Future at 0x12ca39870 state=finished returned int>
    # call_back>>>:<Future at 0x12ca39780 state=finished returned int>
    # call_back>>>:<Future at 0x12ca39cf0 state=finished returned int>


if __name__ == '__main__':
    many_steps()

【3】查看异步回调结果

import os
from concurrent.futures import ProcessPoolExecutor
import time

# 构造进程池，指定进程总数
pool = ProcessPoolExecutor(5)


# 定义线程任务
def task(n):
    print(n, f'当前进程的进程号:>>>{os.getpid()}')
    print(f"这是线程任务中的 n :>>>> {n}")
    time.sleep(2)
    return n * 2


# 定义一个异步回调函数
def call_back(n):
    print(f'call_back>>>:{n} | 返回的结果为:>>>{n.result()}')


def many_steps():
    task_list = []
    for i in range(5):
        # 提交任务到进程池，并获取到返回值，添加一个异步回调函数
        res = pool.submit(task, i).add_done_callback(call_back)
        print(f'这是 pool的返回值:>>>>{res}')

    print('this is a main task')
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # 这是 pool的返回值:>>>>None
    # this is a main task
    # 0 当前进程的进程号:>>>45050
    # 这是线程任务中的 n :>>>> 0
    # 1 当前进程的进程号:>>>45049
    # 这是线程任务中的 n :>>>> 1
    # 2 当前进程的进程号:>>>45046
    # 这是线程任务中的 n :>>>> 2
    # 3 当前进程的进程号:>>>45047
    # 这是线程任务中的 n :>>>> 3
    # 4 当前进程的进程号:>>>45048
    # 这是线程任务中的 n :>>>> 4
    # call_back>>>:<Future at 0x122038910 state=finished returned int> | 返回的结果为:>>>0
    # call_back>>>:<Future at 0x122039510 state=finished returned int> | 返回的结果为:>>>2
    # call_back>>>:<Future at 0x122039840 state=finished returned int> | 返回的结果为:>>>4
    # call_back>>>:<Future at 0x122039ab0 state=finished returned int> | 返回的结果为:>>>6
    # call_back>>>:<Future at 0x122039cf0 state=finished returned int> | 返回的结果为:>>>8


if __name__ == '__main__':
    many_steps()

【五】总结

【1】进程池模版

# 导入模块
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# 构建线程池或进程池
pool_process = ProcessPoolExecutor(5)


# 构造异步任务
def task(n):
    print(f'这是异步传进来的参数 n :>>>> {n}')
    return n ** 2


def main_process():
    task_result_list = []
    for i in range(5):
        # 提交任务
        result = pool_process.submit(task, i)
        print(f'这是异步 {i} 调用的返回结果 :>>>> {result}')
        # 提交线程任务结果
        task_result_list.append(result)

    #  关闭进程池，等待进程池中所有的任务完成
    pool_process.shutdown()

    # 逐个获取到异步迭代的结果
    for task_every in task_result_list:
        print(f'这是异步调用的返回结果 :>>>> {task_every.result()}')


if __name__ == '__main__':
    main_process()

    # 这是异步 0 调用的返回结果 :>>>> <Future at 0x110e59030 state=running>
    # 这是异步 1 调用的返回结果 :>>>> <Future at 0x110e59c60 state=running>
    # 这是异步 2 调用的返回结果 :>>>> <Future at 0x110e59a20 state=running>
    # 这是异步 3 调用的返回结果 :>>>> <Future at 0x110e5a140 state=pending>
    # 这是异步 4 调用的返回结果 :>>>> <Future at 0x110e5a3e0 state=pending>
    # 这是异步传进来的参数 n :>>>> 0
    # 这是异步传进来的参数 n :>>>> 1
    # 这是异步传进来的参数 n :>>>> 2
    # 这是异步传进来的参数 n :>>>> 3
    # 这是异步传进来的参数 n :>>>> 4
    # 这是异步调用的返回结果 :>>>> 0
    # 这是异步调用的返回结果 :>>>> 1
    # 这是异步调用的返回结果 :>>>> 4
    # 这是异步调用的返回结果 :>>>> 9
    # 这是异步调用的返回结果 :>>>> 16

【2】线程池模版

# 导入模块
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# 构建线程池或进程池
pool_thread = ThreadPoolExecutor(5)


# 构造异步任务
def task(n):
    print(f'这是异步传进来的参数 n :>>>> {n}')
    return n ** 2

def main_thread():
    task_result_list = []
    for i in range(5):
        # 提交任务
        result = pool_thread.submit(task, i)
        print(f'这是异步 {i} 调用的返回结果 :>>>> {result}')
        task_result_list.append(result)

    #  关闭进程池，等待进程池中所有的任务完成
    pool_process.shutdown()

    # 逐个获取到异步迭代的结果
    for task_every in task_result_list:
        print(f'这是异步调用的返回结果 :>>>> {task_every.result()}')


if __name__ == '__main__':

    main_thread()

    # 这是异步传进来的参数 n :>>>> 0
    # 这是异步 0 调用的返回结果 :>>>> <Future at 0x12e30ead0 state=finished returned int>
    # 这是异步 1 调用的返回结果 :>>>> <Future at 0x12e30f190 state=pending>
    # 这是异步传进来的参数 n :>>>> 1
    # 这是异步 2 调用的返回结果 :>>>> <Future at 0x12e30f790 state=pending>
    # 这是异步传进来的参数 n :>>>> 2
    # 这是异步传进来的参数 n :>>>> 3
    # 这是异步 3 调用的返回结果 :>>>> <Future at 0x12e33a3e0 state=finished returned int>
    # 这是异步 4 调用的返回结果 :>>>> <Future at 0x12e30f4c0 state=pending>
    # 这是异步调用的返回结果 :>>>> 0
    # 这是异步调用的返回结果 :>>>> 1
    # 这是异步调用的返回结果 :>>>> 4
    # 这是异步调用的返回结果 :>>>> 9
    # 这是异步传进来的参数 n :>>>> 4
    # 这是异步调用的返回结果 :>>>> 16

【3】回调函数模版

# 导入模块
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# 构建线程池或进程池
pool_process = ProcessPoolExecutor(5)
pool_thread = ThreadPoolExecutor(5)


# 构造异步任务
def task(n):
    print(f'这是异步传进来的参数 n :>>>> {n}')
    return n ** 2


# 构造异步调用函数
def call_back(n):
    print(f'这是异步调用函数中接收到的 :>>>> {n.result()}')
    return n.result() ** 2


def main_process():
    for i in range(5):
        # 提交任务
        result_call_back = pool_process.submit(task, i).add_done_callback(call_back)
        print(f'这是异步 {i} 调用的返回结果 :>>>> {result_call_back}')


def main_thread():
    for i in range(5):
        # 提交任务
        result_call_back = pool_thread.submit(task, i).add_done_callback(call_back)
        print(f'这是异步 {i} 调用的返回结果 :>>>> {result_call_back}')


if __name__ == '__main__':
    main_process()

    # 这是异步 0 调用的返回结果 :>>>> None
    # 这是异步 1 调用的返回结果 :>>>> None
    # 这是异步 2 调用的返回结果 :>>>> None
    # 这是异步 3 调用的返回结果 :>>>> None
    # 这是异步 4 调用的返回结果 :>>>> None
    # 这是异步传进来的参数 n :>>>> 0
    # 这是异步传进来的参数 n :>>>> 1
    # 这是异步传进来的参数 n :>>>> 2
    # 这是异步传进来的参数 n :>>>> 3
    # 这是异步传进来的参数 n :>>>> 4
    # 这是异步调用函数中接收到的 :>>>> 0
    # 这是异步调用函数中接收到的 :>>>> 1
    # 这是异步调用函数中接收到的 :>>>> 4
    # 这是异步调用函数中接收到的 :>>>> 9
    # 这是异步调用函数中接收到的 :>>>> 16

    # main_thread()

    # 这是异步传进来的参数 n :>>>> 0
    # 这是异步调用函数中接收到的 :>>>> 0
    # 这是异步 0 调用的返回结果 :>>>> None
    # 这是异步 1 调用的返回结果 :>>>> None
    # 这是异步传进来的参数 n :>>>> 1
    # 这是异步调用函数中接收到的 :>>>> 1
    # 这是异步 2 调用的返回结果 :>>>> None
    # 这是异步传进来的参数 n :>>>> 2
    # 这是异步传进来的参数 n :>>>> 3
    # 这是异步调用函数中接收到的 :>>>> 9
    # 这是异步 3 调用的返回结果 :>>>> None
    # 这是异步调用函数中接收到的 :>>>> 4
    # 这是异步 4 调用的返回结果 :>>>> None
    # 这是异步传进来的参数 n :>>>> 4
    # 这是异步调用函数中接收到的 :>>>> 16
Chimengmeng
关注
并发编程——进程池与线程池
Alex
02-08 678
一、简单介绍 在学习了多进程或多线程之后，我们可能会迫不及待地基于多进程或多线程做一些开发，然而毫无节制的开启进程或线程是十分危险的。 服务开启的进程数或线程数都会随着并发的客户端数目地增多而增多，这会对服务端主机带来巨大的压力，甚至于不堪重负而瘫痪。 所以我们必须对服务端开启的进程数或线程数加以控制，让机器在一个自己可以承受的范围内运行，这就是进程池或线程池的用途，例如进程池，就是用来存放进程的...
python 爬虫相关语法及知识
weixin_41569825的博客
05-23 2910
1、urllib相关语法，使用 """urllib的使用""" import urllib.request # 向指定URL发送请求，获取响应。 response = urllib.request.urlopen('http://httpbin.org/anything') # 获取响应内容 content = response.read().decode('utf-8') print(content) # 类型 print(type(response)) # 响应码，正常则响应码为200 pr
进程池与线程池
weixin_34365635的博客
11-01 165
在介绍进程池和线程池之前，我们需要对其原理有一个了解。总所周知，进程和线程都是不可被重复利用的，在实现高并发中，这会极大的浪费资源。所以首先我们应该想办法实现线程和进程的可重复利用，而生产者与消费者模式就可以很好地解决这个问题。当我们需要开启多个线程或进程时，难道只能一个个去开吗？这时我们可以开辟一个进程池或线程池，可以一次就开启多个进程或线程，池的简单实现也可以...
进程池和线程池
dong18292000671的博客
06-27 394
用new、malloc申请内存时，由于每次申请的大小不同，最后可能导致会有许多内存碎片无法使用，造成内存浪费和不好管理的问题。内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等的内存块留做备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够则继续申请新的内存。这样做有效的避免了内存碎片，提高了内存使用效率。而进程池（线程池与进程池的概念基本一致）就引用了内存池的思想，由服务
--- lowercaseOutputLabelNames: true lowercaseOutputName: true whitelistObjectNames: ["java.lang:type=OperatingSystem"] blacklistObjectNames: [] rules: - pattern: 'java.lang<type=OperatingSystem><>(committed_virtual_memory|free_physical_memory|free_swap_space|total_physical_memory|total_swap_space)_size:' name: os_$1_bytes type: GAUGE attrNameSnakeCase: true - pattern: 'java.lang<type=OperatingSystem><>((?!process_cpu_time)\w+):' name: os_$1 type: GAUGE attrNameSnakeCase: true 解释代码后，解释# HELP jvm_info VM version info # TYPE jvm_info gauge jvm_info{runtime="Java(TM) SE Runtime Environment",vendor="Oracle Corporation",version="1.7.0_79-b15",} 1.0 # HELP os_process_cpu_load java.lang:name=null,type=OperatingSystem,attribute=ProcessCpuLoad # TYPE os_process_cpu_load gauge os_process_cpu_load 0.07142857142857142 # HELP os_open_file_descriptor_count java.lang:name=null,type=OperatingSystem,attribute=OpenFileDescriptorCount # TYPE os_open_file_descriptor_count gauge os_open_file_descriptor_count 84.0 # HELP os_max_file_descriptor_count java.lang:name=null,type=OperatingSystem,attribute=MaxFileDescriptorCount # TYPE os_max_file_descriptor_count gauge os_max_file_descriptor_count 4096.0 # HELP os_total_swap_space_bytes java.lang:name=null,type=OperatingSystem,attribute=TotalSwapSpaceSize # TYPE os_total_swap_space_bytes gauge os_total_swap_space_bytes 4.160745472E9 # HELP os_total_physical_memory_bytes java.lang:name=null,type=OperatingSystem,attribute=TotalPhysicalMemorySize # TYPE os_total_physical_memory_bytes gauge os_total_physical_memory_bytes 8.201289728E9 # HELP os_system_cpu_load java.lang:name=null,type=OperatingSystem,attribute=SystemCpuLoad # TYPE os_system_cpu_load gauge os_system_cpu_load 0.10714285714285714 # HELP os_committed_virtual_memory_bytes java.lang:name=null,type=OperatingSystem,attribute=CommittedVirtualMemorySize # TYPE os_committed_virtual_memory_bytes gauge os_committed_virtual_memory_bytes 3.57505024E9 # HELP os_system_load_average java.lang:name=null,type=OperatingSystem,attribute=SystemLoadAverage # TYPE os_system_load_average gauge os_system_load_average 0.17 # HELP os_free_physical_memory_bytes java.lang:name=null,type=OperatingSystem,attribute=FreePhysicalMemorySize # TYPE os_free_physical_memory_bytes gauge os_free_physical_memory_bytes 6.509023232E9 # HELP os_available_processors java.lang:name=null,type=OperatingSystem,attribute=AvailableProcessors # TYPE os_available_processors gauge os_available_processors 2.0 # HELP os_free_swap_space_bytes java.lang:name=null,type=OperatingSystem,attribute=FreeSwapSpaceSize # TYPE os_free_swap_space_bytes gauge os_free_swap_space_bytes 4.160745472E9 # HELP jmx_scrape_duration_seconds Time this JMX scrape took, in seconds. # TYPE jmx_scrape_duration_seconds gauge jmx_scrape_duration_seconds 0.001119413 # HELP jmx_scrape_error Non-zero if this scrape failed. # TYPE jmx_scrape_error gauge jmx_scrape_error 0.0 # HELP jmx_scrape_cached_beans Number of beans with their matching rule cached # TYPE jmx_scrape_cached_beans gauge jmx_scrape_cached_beans 0.0 # HELP jvm_buffer_pool_used_bytes Used bytes of a given JVM buffer pool. # TYPE jvm_buffer_pool_used_bytes gauge jvm_buffer_pool_used_bytes{pool="direct",} 8192.0 jvm_buffer_pool_used_bytes{pool="mapped",} 0.0 # HELP jvm_buffer_pool_capacity_bytes Bytes capacity of a given JVM buffer pool. # TYPE jvm_buffer_pool_capacity_bytes gauge jvm_buffer_pool_capacity_bytes{pool="direct",} 8192.0 jvm_buffer_pool_capacity_bytes{pool="mapped",} 0.0 # HELP jvm_buffer_pool_used_buffers Used buffers of a given JVM buffer pool. # TYPE jvm_buffer_pool_used_buffers gauge jvm_buffer_pool_used_buffers{pool="direct",} 1.0 jvm_buffer_pool_used_buffers{pool="mapped",} 0.0 # HELP jvm_memory_objects_pending_finalization The number of objects waiting in the finalizer queue. # TYPE jvm_memory_objects_pending_finalization gauge jvm_memory_objects_pending_finalization 0.0 # HELP jvm_memory_bytes_used Used bytes of a given JVM memory area. # TYPE jvm_memory_bytes_used gauge jvm_memory_bytes_used{area="heap",} 2.38314152E8 jvm_memory_bytes_used{area="nonheap",} 5.160628E7 # HELP jvm_memory_bytes_committed Committed (bytes) of a given JVM memory area. # TYPE jvm_memory_bytes_committed gauge jvm_memory_bytes_committed{area="heap",} 5.19569408E8 jvm_memory_bytes_committed{area="nonheap",} 5.2822016E7 # HELP jvm_memory_bytes_max Max (bytes) of a given JVM memory area. # TYPE jvm_memory_bytes_max gauge jvm_memory_bytes_max{area="heap",} 1.823473664E9 jvm_memory_bytes_max{area="nonheap",} 1.3631488E8 # HELP jvm_memory_bytes_init Initial bytes of a given JVM memory area. # TYPE jvm_memory_bytes_init gauge jvm_memory_bytes_init{area="heap",} 1.28145152E8 jvm_memory_bytes_init{area="nonheap",} 2.4576E7 # HELP jvm_memory_pool_bytes_used Used bytes of a given JVM memory pool. # TYPE jvm_memory_pool_bytes_used gauge jvm_memory_pool_bytes_used{pool="Code Cache",} 3370048.0 jvm_memory_pool_bytes_used{pool="PS Eden Space",} 1.78591736E8 jvm_memory_pool_bytes_used{pool="PS Survivor Space",} 2.4223408E7 jvm_memory_pool_bytes_used{pool="PS Old Gen",} 3.5499008E7 jvm_memory_pool_bytes_used{pool="PS Perm Gen",} 4.8236232E7 # HELP jvm_memory_pool_bytes_committed Committed bytes of a given JVM memory pool. # TYPE jvm_memory_pool_bytes_committed gauge jvm_memory_pool_bytes_committed{pool="Code Cache",} 4063232.0 jvm_memory_pool_bytes_committed{pool="PS Eden Space",} 4.09468928E8 jvm_memory_pool_bytes_committed{pool="PS Survivor Space",} 2.4641536E7 jvm_memory_pool_bytes_committed{pool="PS Old Gen",} 8.5458944E7 jvm_memory_pool_bytes_committed{pool="PS Perm Gen",} 4.8758784E7 # HELP jvm_memory_pool_bytes_max Max bytes of a given JVM memory pool. # TYPE jvm_memory_pool_bytes_max gauge jvm_memory_pool_bytes_max{pool="Code Cache",} 5.0331648E7 jvm_memory_pool_bytes_max{pool="PS Eden Space",} 6.31242752E8 jvm_memory_pool_bytes_max{pool="PS Survivor Space",} 2.4641536E7 jvm_memory_pool_bytes_max{pool="PS Old Gen",} 1.367343104E9 jvm_memory_pool_bytes_max{pool="PS Perm Gen",} 8.5983232E7 # HELP jvm_memory_pool_bytes_init Initial bytes of a given JVM memory pool. # TYPE jvm_memory_pool_bytes_init gauge jvm_memory_pool_bytes_init{pool="Code Cache",} 2555904.0 jvm_memory_pool_bytes_init{pool="PS Eden Space",} 3.2505856E7 jvm_memory_pool_bytes_init{pool="PS Survivor Space",} 5242880.0 jvm_memory_pool_bytes_init{pool="PS Old Gen",} 8.5458944E7 jvm_memory_pool_bytes_init{pool="PS Perm Gen",} 2.2020096E7 # HELP jvm_memory_pool_collection_used_bytes Used bytes after last collection of a given JVM memory pool. # TYPE jvm_memory_pool_collection_used_bytes gauge jvm_memory_pool_collection_used_bytes{pool="PS Eden Space",} 0.0 jvm_memory_pool_collection_used_bytes{pool="PS Survivor Space",} 2.4223408E7 jvm_memory_pool_collection_used_bytes{pool="PS Old Gen",} 0.0 jvm_memory_pool_collection_used_bytes{pool="PS Perm Gen",} 0.0 # HELP jvm_memory_pool_collection_committed_bytes Committed after last collection bytes of a given JVM memory pool. # TYPE jvm_memory_pool_collection_committed_bytes gauge jvm_memory_pool_collection_committed_bytes{pool="PS Eden Space",} 4.09468928E8 jvm_memory_pool_collection_committed_bytes{pool="PS Survivor Space",} 2.4641536E7 jvm_memory_pool_collection_committed_bytes{pool="PS Old Gen",} 0.0 jvm_memory_pool_collection_committed_bytes{pool="PS Perm Gen",} 0.0 # HELP jvm_memory_pool_collection_max_bytes Max bytes after last collection of a given JVM memory pool. # TYPE jvm_memory_pool_collection_max_bytes gauge jvm_memory_pool_collection_max_bytes{pool="PS Eden Space",} 6.31242752E8 jvm_memory_pool_collection_max_bytes{pool="PS Survivor Space",} 2.4641536E7 jvm_memory_pool_collection_max_bytes{pool="PS Old Gen",} 1.367343104E9 jvm_memory_pool_collection_max_bytes{pool="PS Perm Gen",} 8.5983232E7 # HELP jvm_memory_pool_collection_init_bytes Initial after last collection bytes of a given JVM memory pool. # TYPE jvm_memory_pool_collection_init_bytes gauge jvm_memory_pool_collection_init_bytes{pool="PS Eden Space",} 3.2505856E7 jvm_memory_pool_collection_init_bytes{pool="PS Survivor Space",} 5242880.0 jvm_memory_pool_collection_init_bytes{pool="PS Old Gen",} 8.5458944E7 jvm_memory_pool_collection_init_bytes{pool="PS Perm Gen",} 2.2020096E7 # HELP jvm_classes_currently_loaded The number of classes that are currently loaded in the JVM # TYPE jvm_classes_currently_loaded gauge jvm_classes_currently_loaded 8198.0 # HELP jvm_classes_loaded_total The total number of classes that have been loaded since the JVM has started execution # TYPE jvm_classes_loaded_total counter jvm_classes_loaded_total 8198.0 # HELP jvm_classes_unloaded_total The total number of classes that have been unloaded since the JVM has started execution # TYPE jvm_classes_unloaded_total counter jvm_classes_unloaded_total 0.0 # HELP jmx_exporter_build_info A metric with a constant '1' value labeled with the version of the JMX exporter. # TYPE jmx_exporter_build_info gauge jmx_exporter_build_info{version="0.18.0",name="jmx_prometheus_javaagent",} 1.0 # HELP jvm_threads_current Current thread count of a JVM # TYPE jvm_threads_current gauge jvm_threads_current 29.0 # HELP jvm_threads_daemon Daemon thread count of a JVM # TYPE jvm_threads_daemon gauge jvm_threads_daemon 28.0 # HELP jvm_threads_peak Peak thread count of a JVM # TYPE jvm_threads_peak gauge jvm_threads_peak 31.0 # HELP jvm_threads_started_total Started thread count of a JVM # TYPE jvm_threads_started_total counter jvm_threads_started_total 33.0 # HELP jvm_threads_deadlocked Cycles of JVM-threads that are in deadlock waiting to acquire object monitors or ownable synchronizers # TYPE jvm_threads_deadlocked gauge jvm_threads_deadlocked 0.0 # HELP jvm_threads_deadlocked_monitor Cycles of JVM-threads that are in deadlock waiting to acquire object monitors # TYPE jvm_threads_deadlocked_monitor gauge jvm_threads_deadlocked_monitor 0.0 # HELP jvm_threads_state Current count of threads by state # TYPE jvm_threads_state gauge jvm_threads_state{state="NEW",} 0.0 jvm_threads_state{state="WAITING",} 14.0 jvm_threads_state{state="TIMED_WAITING",} 7.0 jvm_threads_state{state="UNKNOWN",} 0.0 jvm_threads_state{state="TERMINATED",} 0.0 jvm_threads_state{state="RUNNABLE",} 8.0 jvm_threads_state{state="BLOCKED",} 0.0 # HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. # TYPE process_cpu_seconds_total counter process_cpu_seconds_total 17.38 # HELP process_start_time_seconds Start time of the process since unix epoch in seconds. # TYPE process_start_time_seconds gauge process_start_time_seconds 1.749808021796E9 # HELP process_open_fds Number of open file descriptors. # TYPE process_open_fds gauge process_open_fds 84.0 # HELP process_max_fds Maximum number of open file descriptors. # TYPE process_max_fds gauge process_max_fds 4096.0 # HELP process_virtual_memory_bytes Virtual memory size in bytes. # TYPE process_virtual_memory_bytes gauge process_virtual_memory_bytes 3.575046144E9 # HELP process_resident_memory_bytes Resident memory size in bytes. # TYPE process_resident_memory_bytes gauge process_resident_memory_bytes 6.88590848E8 # HELP jmx_config_reload_failure_total Number of times configuration have failed to be reloaded. # TYPE jmx_config_reload_failure_total counter jmx_config_reload_failure_total 0.0 # HELP jmx_config_reload_success_total Number of times configuration have successfully been reloaded. # TYPE jmx_config_reload_success_total counter jmx_config_reload_success_total 0.0 # HELP jvm_memory_pool_allocated_bytes_total Total bytes allocated in a given JVM memory pool. Only updated after GC, not continuously. # TYPE jvm_memory_pool_allocated_bytes_total counter jvm_memory_pool_allocated_bytes_total{pool="PS Survivor Space",} 3.523552E7 jvm_memory_pool_allocated_bytes_total{pool="Code Cache",} 3718208.0 jvm_memory_pool_allocated_bytes_total{pool="PS Perm Gen",} 4.5692072E7 jvm_memory_pool_allocated_bytes_total{pool="PS Eden Space",} 1.43917056E9 jvm_memory_pool_allocated_bytes_total{pool="PS Old Gen",} 3.5499008E7 # HELP jvm_gc_collection_seconds Time spent in a given JVM garbage collector in seconds. # TYPE jvm_gc_collection_seconds summary jvm_gc_collection_seconds_count{gc="PS Scavenge",} 11.0 jvm_gc_collection_seconds_sum{gc="PS Scavenge",} 0.15 jvm_gc_collection_seconds_count{gc="PS MarkSweep",} 0.0 jvm_gc_collection_seconds_sum{gc="PS MarkSweep",} 0.0 # HELP jmx_config_reload_failure_created Number of times configuration have failed to be reloaded. # TYPE jmx_config_reload_failure_created gauge jmx_config_reload_failure_created 1.749808021823E9 # HELP jmx_config_reload_success_created Number of times configuration have successfully been reloaded. # TYPE jmx_config_reload_success_created gauge jmx_config_reload_success_created 1.749808021822E9 # HELP jvm_memory_pool_allocated_bytes_created Total bytes allocated in a given JVM memory pool. Only updated after GC, not continuously. # TYPE jvm_memory_pool_allocated_bytes_created gauge jvm_memory_pool_allocated_bytes_created{pool="PS Survivor Space",} 1.749808022447E9 jvm_memory_pool_allocated_bytes_created{pool="Code Cache",} 1.749808022448E9 jvm_memory_pool_allocated_bytes_created{pool="PS Perm Gen",} 1.749808022448E9 jvm_memory_pool_allocated_bytes_created{pool="PS Eden Space",} 1.749808022448E9 jvm_memory_pool_allocated_bytes_created{pool="PS Old Gen",} 1.749808022448E9
最新发布
06-14
3.CPU使用率：解释JVM进程和线程的CPU使用情况。4.GC收集时间：垃圾收集的相关指标。5.操作系统相关指标：与JVM运行相关的系统级指标。注意：引用[1]中提到了一些工具（jps,jstat,jinfo,jstack,jmap,jcmd）的使用...
IOS-Swift面试相关基础
CQUPT—ZHX
03-04 2433
Xcode部分 Storyboard基础控件： 视图控制器在SB种称为场景 控件： 1.Label：可包含任意数量的文本，UILabel可收缩，换行以及截断文本。 2.Button：按钮。 3.Segmentel Control：可表示单个或多个选择或命令列表，可显示文本或图像，但无法同时显示两者。 4.Text Field：用户可编辑的文本框。 5.Slider：可滑动的水平条。 6.Switc...
Spring Cloud Gateway 雪崩了，该怎么办不要慌
weixin_54556126的博客
09-28 1770
问题现象与背景 昨晚我们的网关雪崩了一段时间，现象是：1.不断有各种微服务报异常：在写 HTTP 响应的时候，连接已经关闭： reactor.netty.http.client.PrematureCloseException: Connection prematurely closed BEFORE response 复制代码2.同时还有请求还没读取完，连接已经关闭的异常： org.springframework.http.converter.HttpMessageNotReadableException:
Spring Cloud Gateway 雪崩了，我 TM 人傻了
syh121的博客
09-27 783
问题现象与背景 昨晚我们的网关雪崩了一段时间，现象是： 1.不断有各种微服务报异常：在写 HTTP 响应的时候，连接已经关闭： reactor.netty.http.client.PrematureCloseException: Connection prematurely closed BEFORE response 复制代码 2.同时还有请求还没读取完，连接已经关闭的异常： org.springframework.http.converter.HttpMessageNotReadable
Linux进程池与线程池以及线程池的简单实现
Hyacinth_Dy
06-04 1203
进程池是由服务器预先创建的一组子进程，这些子进程的数目在3-10个之间。httpd守护进程就是使用了包含7个子进程的进程池来实现并发的。线程池中的线程数量应该和CPU数量差不多进程池中的所有子进程都运行着相同的代码，并具有相同的属性，比如优先级，PGID等等。
【进程池与线程池】
Ban_a的博客
04-21 818
文章目录进程池与线程池concurrent.fututres 模块`ProcessPoolExecutor `类–进程池开启方法及属性介绍ThreadPoolExecutor类–线程池的开启 进程池与线程池 在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能
进程池&线程池
qq_41292216的博客
08-04 368
进程池和线程池概述 进程池和线程池相似，所以这里我们以进程池为例介绍，下面对进程池的讨论完全适用于线程池（如果没有特殊声明）。 进程池是由服务器预先创建的一组子进程，这些子进程的数目在3~10个之间（典型情况）。线程池的数量应该和CPU数量差不多。 进程池中的所有子进程都运行者相同的代码，并具有相同的属性。因为进程池在服务器启动之初就创建好了，所以每个子进程都相对“干净”，即它们没有打开不必...
线程池和进程池
willow_LI的博客
11-04 343
线程池和进程池 线程安全 ​ 单线程程序不会有线程安全的问题，但多线程程序就可能出现线程安全的问题，举个例子，当多个线程同时访问同一个数据时并对其做出操作时，可能会出错，原因是线程一访问某个数据并修改了它，但还没来得及保存，线程二也访问了这个数据，但取到的数据还是未修改的，所以线程二取到的是一个脏数据（错误数据）。 线程安全解决方案——加锁 1.Lock锁 from threading import Thread,Lock#导入线程模块和Lock锁模块 account = 10000#定义一个全局变量，表示
线程池与进程池
Number_0_0的博客
06-02 913
进程池和线程池 池的概念 由于服务器的硬件资源“充裕”，那么提高服务器性能的一个很直接的方法就是以空间换时间，即“浪费”服务器的硬件资源，以换取其运行效率。这就是池的概念。池是一组资源的集合，这组资源在服务器启动之初就完全被创建并初始化，这称为静态资源分配。当服务器进入正是运行阶段，即开始处理客户请求的时候，如果它需要相关的资源，就可以直接从池中获取，无需动态分配。很显然，直接从池中取
HALCON 10.0与11.0版本试用版许可证配置指南
标题中提到的"Halcon 10.0和Halcon11.0的license"指的是Halcon软件的许可证文件，Halcon是由MVTec公司开发的商业机器视觉软件包。软件许可证是控制软件使用权限的机制，确保软件只能根据许可协议的要求被使用。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值