查看进程的id、队列的使用(Queue)、解决进程之间数据隔离问题(队列)、生产者消费者模型(重要)、线程相关

已于 2023-07-06 18:36:02 修改
阅读量253 收藏
点赞数
文章标签： python pycharm windows 开发语言
于 2023-07-06 17:32:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44145338/article/details/131577360
版权
文章介绍了Python中查看进程ID的方法，展示了如何创建和管理子进程，以及使用队列进行进程间通信。讨论了队列的数据结构和操作，如入队、出队，并给出了不同场景下的生产者消费者模型示例。同时，文章还对比了进程和线程的特性，并提供了开启线程和多线程的代码示例。
摘要由CSDN通过智能技术生成

一、查看进程的id

'''
进程都有几个属性：进程名、进程id（pid --> process id）

每一个进程都有一个唯一的id号，通过这个id号就能找到这个进程

Linux -----> 杀进程 -----> kill -9 1001 -----> pkill 进程名

'''

import os
import time

from multiprocessing import Process


def task():
    print('task中的子进程号：', os.getpid())  # 21716
    print('主进程中的进程号：', os.getppid())  # 3420
    time.sleep(5)


if __name__ == '__main__':
    p = Process(target=task, )
    p.start()

    查看子进程p的进程号
    print('子进程的进程号：', p.pid)  # 21716

    查看主进程的进程号
    '''os.getgid()这一句写在哪个进程下，输出的就是这个进程的进程号'''
    print('主进程的进程号：', os.getpid())  # 3420

    time.sleep(10)

二、队列的使用

"""
常见的数据结构：链表、单链表、双链表、循环链表、栈、队列、树、
二叉树、平衡二叉树、红黑树、b树、b+树、b-树、图等

队列：先进先出

"""

from multiprocessing import Queue

if __name__ == '__main__':
    """
        思考：怎么样得到一个队列呢？
        在python中，内置的有一个类，Queue
    """
    队列的大小默认很大(2147483647)
    q = Queue(3)  # 这里假如有3个


    1.如何入队
    q.put("helloworld")
    q.put("helloworld1")
    q.put("helloworld2")

    2.出队
    print(q.get())
    print(q.get())
    print(q.get())
    print(q.get())

if __name__ == '__main__':
    """
        思考：怎么样得到一个队列呢？
        在python中，内置的有一个类，Queue
    """
    # 队列的大小默认很大(2147483647)
    q = Queue(3)  # 这里写3个

    '''
        put、get的参数有obj, block=True, timeout=None
    '''
***********************************************************************
    # 1.如何入队
    q.put("helloworld")
    q.put("helloworld1")
    q.put("helloworld2")

    '''若指定了block参数，当队列满的时候，放不进去的时候，就会直接报错'''
    # q.put("helloworld3", block=False)  # 报错： queue.Full

    '''若指定了timeout参数，当队列中放入数据的时候，等待3秒，如果放不进去，直接报错'''
    # q.put("helloworld3", timeout=3)

    '''往队列中放入数据的时候，放不进去直接报错'''
    # q.put_nowait('helloworld3')


    # 2.出队
    print(q.get())
    print(q.get())
    print(q.get())

    # print(q.get(block=False))  # 报错
    # print(q.get(timeout=3))  # 报错
    # q.get_nowait()  # 报错
    
    '''注意：队列中剩余的数据量，这个方法的结果有点不准确'''
    # print(q.qsize())
    # print(q.empty())  # True
    print(q.full())  # False

三、解决进程之间的数据隔离问题

def task(q):
    a = 1
    q.put('子进程写入的数据')
    q.put(a)


from multiprocessing import Process
from multiprocessing import Queue

if __name__ == '__main__':
    q = Queue(3)

    '''
        若在子进程中放入一个数据，然后在主进程中取出这个数据，
        若能取到，则说明主进程和子进程之间通信了。若不能，则说明没有通信
    '''
    p = Process(target=task, args=(q, ))
    p.start()

    '''在主进程中取出子进程写进去的数据'''
    print(q.get())
    print(q.get())

    """
        现在队列中的数据在哪里存着？在内存中存着的，当数据量很大的时候，很占用机器的内存
        
        注意：当前使用较多的消息队列有：RabbitMQ，RocketMQ,ActiveMQ、Kafka、ZeroMQ，MetaMQ
    """

四、生产者消费者模型

版本1：
def producer(q):
    # 让生产者生产10个
    for i in range(10):
        '''生成的东西放在哪里呢？队列里'''
        q.put('这是第%s个' % i)


def consumer(q):
    '''拿东西从哪里拿呢？也是队列中'''
    while True:
        res = q.get()
        print(res)


from multiprocessing import Process
from multiprocessing import Queue


if __name__ == '__main__':
    q = Queue(20)

    p = Process(target=producer, args=(q, ))
    p.start()

    c = Process(target=consumer, args=(q, ))
    c.start()


# 版本2：
def producer(q):
    # 让生产者生产10个
    for i in range(10):
        '''生成的东西放在哪里呢？队列里'''
        q.put('这是第%s个' % i)
    q.put(None)


def consumer(q):
    '''拿东西从哪里拿呢？也是队列中'''
    while True:
        res = q.get()
        print(res)
        '''若是有多个生产者，则不适宜用q.empty()'''
        # if q.empty():
        #     break
        if res is None:
            break



版本3：
def producer(q):
    # 让生产者生产10个
    for i in range(10):
        '''生成的东西放在哪里呢？队列里'''
        q.put('这是第%s个' % i)


def consumer(q):
    '''拿东西从哪里拿呢？也是队列中'''
    while True:
        res = q.get()
        print(res)
        '''若是有多个生产者，则不适宜用q.empty()'''
        # if q.empty():
        #     break
        if res is None:
            break


from multiprocessing import Process
from multiprocessing import Queue


if __name__ == '__main__':
    q = Queue(20)

    p = Process(target=producer, args=(q, ))
    p.start()

    c = Process(target=consumer, args=(q, ))
    c.start()
    '''
        不能放在这个地方：是因为：开启进程有延迟，不会立刻开起来，
        先执行主进程的代码，把None放在了队列的第一个，当消费者消费数据的时候，
        直接就结束了
    '''
    q.put(None)



版本4：多生产者、少消费者
def producer(q, name, food):
    # 让生产者生产10个
    for i in range(10):
        '''生成的东西放在哪里呢？队列里'''
        q.put('生产者：%s,生产了第%s个 %s' % (name, i, food))


def consumer(q):
    '''拿东西从哪里拿呢？也是队列中'''
    while True:
        res = q.get()
        '''若是有多个生产者，则不适宜用q.empty()'''
        # if q.empty():
        #     break
        if res is None:
            break
        print(res)


from multiprocessing import Process
from multiprocessing import Queue

if __name__ == '__main__':
    q = Queue(20)

    # 4个生产者
    p1 = Process(target=producer, args=(q, 'python', 'py'))
    p2 = Process(target=producer, args=(q, 'java', 'main'))
    p3 = Process(target=producer, args=(q, 'json', 'jjson'))
    p4 = Process(target=producer, args=(q, 'golang', 'go'))
    p1.start()
    p2.start()
    p3.start()
    p4.start()

    # 2个消费者
    c1 = Process(target=consumer, args=(q,))
    c2 = Process(target=consumer, args=(q,))
    c1.start()
    c2.start()

    # 让子进程先进行
    p1.join()
    p2.join()
    p3.join()
    p4.join()

    '''
        不能放在这个地方：是因为：开启进程有延迟，不会立刻开起来，
        先执行主进程的代码，把None放在了队列的第一个，当消费者消费数据的时候，
        直接就结束了
    '''
    q.put(None)
    q.put(None)



版本5：少生产者、多消费者
def producer(q, name, food):
    # 让生产者生产10个
    for i in range(10):
        '''生成的东西放在哪里呢？队列里'''
        q.put('生产者：%s,生产了第%s个 %s' % (name, i, food))


def consumer(q):
    '''拿东西从哪里拿呢？也是队列中'''
    while True:
        res = q.get()
        '''若是有多个生产者，则不适宜用q.empty()'''
        # if q.empty():
        #     break
        if res is None:
            break
        print(res)


from multiprocessing import Process
from multiprocessing import Queue

if __name__ == '__main__':
    q = Queue(20)

    # 2个生产者
    p1 = Process(target=producer, args=(q, 'python', 'py'))
    p2 = Process(target=producer, args=(q, 'java', 'main'))
    p1.start()
    p2.start()

    # 2个消费者
    c1 = Process(target=consumer, args=(q,))
    c2 = Process(target=consumer, args=(q,))
    c3 = Process(target=consumer, args=(q,))
    c4 = Process(target=consumer, args=(q,))
    c1.start()
    c2.start()
    c3.start()
    c4.start()

    # 等待生产者进程结束
    p1.join()
    p2.join()

    q.put(None)
    q.put(None)
    q.put(None)
    q.put(None)

五、线程相关

1.开启线程

'''
线程理论：
    进程是一个任务的执行过程，在这个过程中实际做事的是线程，线程是开在进程里面的，
    需要先有进程，再有线程，一个进程中至少有一个线程，当然，也可以有多个线程

进程是自愿分配的基本单位，线程是CPU执行的最小单位

进程和线程都是由操作系统来调度的，协程是由程序员来调度的

进程 >>> 线程 >>> 协程
资源消耗最多的 >>> 线程的资源 >>> 协程

'''
from multiprocessing import Process
from threading import Thread
import threading


def task(name, name1, age):
    print('task执行了')
    print(name)
    print(name1)
    print(age)

    print(threading.currentThread())  # <Thread(duck, started 16460)>


if __name__ == '__main__':

    """
        参数：
            group=None, target=None, name=None,
            args=(), kwargs=None, *, daemon=None
            
        修改线程名称：
        name = 'name1'
    """
    t = Thread(target=task, name='lin', args=('kevin', 'tank'), kwargs={'age': 18})

    # 设置守护线程：主线程结束，子线程也跟着结束
    # t.daemon = True

    # 开启线程
    t.start()

    # 查看线程名
    # print(t.name)  # lin

    print(123)

    # 线程的方法
    print(t.is_alive())
    print(t.getName())

    t.setName('duck')
    print(t.name)

    print(465)

    # 查看最近的线程
    print(threading.currentThread())  # <_MainThread(MainThread, started 18528)>

2.开启多线程

from threading import Thread


def task(i):
    print(i)


if __name__ == '__main__':

    tt = []

    for i in range(5):
        t = Thread(target=task, args=(i, ))
        t.start()
        # t.join()
        tt.append(t)

    for j in tt:
        j.join()

    print('开启多线程')
    print(123)

六、进程和线程之间的比较

import time

from multiprocessing import Process
from threading import Thread


def work():
    print('hello')
    time.sleep(1)


if __name__ == '__main__':

    start_time = time.time()
    # # 在主进程下开启线程
    # t = Thread(target=work)
    # t.start()
    # t.join()
    # print('主线程/主进程')
    # print('time:', time.time() - start_time)
    # # time: 1.0061957836151123


    # 在主进程下开启子进程
    p = Process(target=work)
    p.start()
    p.join()
    print('主线程/主进程')

    print('time:', time.time() - start_time)
    # time: 1.067737340927124
    '''
        执行的时间不一样，线程的时间远远小于进程的执行时间
    '''

七、修改线程的数据

def work():
    print('hello')
    global n
    n = 0


if __name__ == '__main__':

    n = 1

    # 在主进程下开启线程
    t = Thread(target=work)
    t.start()
    t.join()

    print('n=', n)  # n= 0
林光虚霁晓
关注
查看进程号、队列的使用
菜CAI的博客
07-11 524
先导入模块再定义一个队列并定义队列大小，队列的大小就是n，如果n不填责就是队列的默认大小，非常大。
Queue 实现生产者消费者模型(实例讲解)
12-25
Python中，队列是线程间最常用的交换数据的形式。 Python Queue模块有三种队列及构造函数: 1、Python Queue模块的FIFO队列先进先出。 class Queue.Queue(maxsize) 2、LIFO类似于堆，即先进后出。 class Queue....
Linux系统如何查看当前程序的进程ID，进程ID的启动命令，以及进程的CPU和内存等资源消耗情况
qq_15821487的博客
04-25 8642
top。
数据结构学习笔记——队列
HiSi_的博客
09-26 1642
队列队列的定义队列的顺序存储结构和基本运算的实现类型声明初始化队列销毁队列判断队列是否为空进队列出队列环形队列基本运算初始化销毁判断队列是否为空进队列出队列链栈链栈的基本运算初始化销毁判断是否为空进队列出队列不带头结点只有一个尾节点指针的循环单链表存储队列 队列的定义 队列的顺序存储结构和基本运算的实现 类型声明 初始化队列 销毁队列 判断队列是否为空 进队列 出队列 环形队列 基本运算 初始化 销毁 判断队列是否为空 进队列 出队列 链栈 链栈的基本运算 初始化 销毁 判断是否为空 进队列 出队列 不带头
java queue源码_Java 容器源码分析之Queue
weixin_39922151的博客
02-16 109
下面是allocateElements方法的实现：Java代码private void allocateElements(intnumElements) {int initialCapacity =MIN_INITIAL_CAPACITY;//Find the best power of two to hold elements.//Tests "<=" because arrays a...
Linux——一文彻底了解进程id和线程id的关系（什么是pid、tgid、lwp、pthread_t）
weixin_61857742的博客
01-21 6562
​首先，我们要清楚，在系统层面只有两个编号：pid、tgid。不妨拿出task_struct结构体（进程PCB）看一看：pid_t pid; pid_t tgid; 我们知道，在linux中进程和线程都使用task_struct结构体实现。在task_struct中：pid即线程id。也就是task_struct的编号，每个task_struct各不相同。tgid叫线程组id。也就是一个进程的id。同一个进程里每一个线程的task_struct中tgid值都一样。当使用ps axj或ps -aL查看进程
ruby线程实现生产者消费者问题示例(队列Queue实现线程同步)
01-20
Ruby线程实现经典的生产者消费者问题，用ruby中的Queue类实现线程同步问题。 代码如下:require “thread” puts “ProAndCon” queue = Queue.new #用队列Queue实现线程同步 producer = Thread.new do 10....
Python进程间通信 multiProcessing Queue队列实现详解
01-01
创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。 Queue([maxsize])创建共享的进程队列。 参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。 底层队列...
Python自定义进程池实例分析【生产者、消费者模型问题】
09-21
本实例分析了如何自定义进程池来解决生产者和消费者模型的问题。生产者消费者模型是一种多线程或多进程通信的典型应用场景，通常用于数据的生产和消费。 在Python中，`multiprocessing`模块提供了进程池的功能，...
Python 进程操作之进程间通过队列共享数据，队列Queue简单示例
09-18
在实际应用中，队列可以被用于更复杂的场景，例如多个生产者进程向队列写入数据，多个消费者进程从队列中读取数据。为了提高效率，队列可以配合分布式缓存系统如Redis使用，这样可以实现更大规模的数据共享和处理。 ...
获取进程ID
08-20
编译环境：VC++6.0 ； 语言：VC++，MFC基于对话框的编程 ；功能：通过映像名称（PS：QQ的映像名称为QQ.exe *32，通过资源管理器即可看到）获取进程ID ； 说明：仅有一个功能，个人兴趣所写，不足之处请指点批评。
（一百五十九）如何查找特定uid的进程
JT的专栏
06-29 4196
参考：https://www.runoob.com/linux/linux-comm-ps.html 目录 1.查找特定uid的进程 2. ps --help 2.1 ps -A 2.2 ps -Af 2.3 ps -AfT 3.总结 1.查找特定uid的进程 1）比如看log发现一个uid为1089的进程，但是不知道对应的进程是什么，可以用如下命令查找 ps -A | gr...
进程的基本属性:进程ID、父进程ID、进程组ID、会话和控制终端
计算机视觉领域
10-10 6392
摘要：本文主要介绍进程的基本属性，基本属性包括:进程ID、父进程ID、进程组ID、会话和控制终端.
进程ID号
emowuyi
12-19 370
关于进程ID号，在深入理解linux内核架构中已经讲得很清楚了。下面是主要的部分。 UNIX进程总是会分配一个号码用于在其命名空间中唯一地标识它们。该号码被称作进程ID号，简称PID。用fork或clone产生的每个进程都由内核自动地分配了一个新的唯一的PID值。 1.进程ID 但每个进程除了PID这个特征值之外，还有其他的ID。有下列几种可能的类型。 处于某个线程组（在一个进程中...
进程的介绍及相关命令
最新发布
wyq2070857323的博客
01-04 1133
硬盘上躺着，执行特点任务的一串代码加载到内存中运行，进程是程序的副本 程是有生命周期的，程序没有进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)
【招招有效】Windows下根据进程ID杀死进程命令教程
追寻上飞的博客
10-12 4428
Taskkill 是 Windows 操作系统中的一个命令，用来终止进程。通过命令提示符，用户可以使用 taskkill 命令结束进程。
进程的各种ID
耿小渣的进阶之路
04-14 1979
pid（进程ID） UNIX进程总是会分配一个号码用于在其命名空间中唯一的标识他们。该号码被称为进程ID号，简称PID。用fork或者clone产生的每个进程都由内核自动的分配一个新的唯一的PID值。 #include <sys/types.h> #include <unistd.h> pid_t getpid( void ); ppid（父进程ID） ...
Python多进程生产者消费者模型详解
"Python多进程下的生产者消费者模型通过使用Queue模块实现，旨在解决生产者与消费者之间数据处理效率不匹配的问题。生产者将数据放入队列，消费者从队列中取出数据，实现两者解耦合。" 在Python中，多进程的生产者...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值