python loguru多进程多线程下丢日志

import time
import os
import multiprocessing

from multiprocessing import Queue, pool


"""
一.Python 使用多进程实现并发编程：
    因为cpython解释器中有GIL存在的原因（每个进程都会维护一个GIL，jpython解释器没有这个问题)，所以在一个进程内，
    即使服务器是多核cpu，同一时刻只能有一个线程在执行任务（一个进程内）。如果存在较多IO，使用多线程是可以提高处理速度的，
    但是如果是cpu密集型任务，使用多线程是有一定瓶颈的。如果需要频繁的创建和销毁任务，可以使用多线程。cpu密集型任务可以考虑使用多进程。
    
二.multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象，这个对象可以理解为是一个独立的进程，可以执行另外的事情.Process语法结构如下：
    Process([group [, target [, name [, args [, kwargs]]]]])
    
    target：如果传递了函数的引用，可以任务这个子进程就执行这里的代码
    args：给target指定的函数传递的参数，以元组的方式传递
    kwargs：给target指定的函数传递命名参数
    name：给进程设定一个名字，可以不设定
    group：指定进程组，大多数情况下用不到
    Process创建的实例对象的常用方法：
    
    start()：启动子进程实例（创建子进程）
    is_alive()：判断进程子进程是否还在活着
    join([timeout])：是否等待子进程执行结束，或等待多少秒
    terminate()：不管任务是否完成，立即终止子进程
    Process创建的实例对象的常用属性：
    
    name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
    pid：当前进程的pid（进程号）
    
三.进程间无法直接共享内存，所以需要使用Queue进行数据的交互:
    初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；

    Queue.qsize()：返回当前队列包含的消息数量；
    
    Queue.empty()：如果队列为空，返回True，反之False ；
    
    Queue.full()：如果队列满了，返回True,反之False；
    
    Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
    
        1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；
        
        2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；
        
        Queue.get_nowait()：相当Queue.get(False)；
        
    Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；
        
        1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；
        
        2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；
        
        Queue.put_nowait(item)：相当Queue.put(item, False)；
        
    注意：
        多个进程同时对一个队列进行读取数据时，有可能会发生数据丢失的情况
"""


def multi_1():
　　# 测试主进程默认会等待子进程
    time.sleep(2)
    print("multi_1 子进程运行结束")


def multi_2(pid, name="lowman"):
　　# 测试向子进程的任务函数中传递参数
    time.sleep(2)
    print("主进程的pid:{}".format(pid))
    # print(name)


def test_queue_write(queue):
　　# 往队列中写入数据
    my_list = ["L", "O", "W", "M", "A", "N"]
    for i in my_list:

        # 判断队列是否已满,这样设置的话，需要注意数据量的大小和队列的容量，否则循环写入数据的时候会造成的数据的丢失
        # if not queue.full():
        #     queue.put(i)

        # 如果队列已满，就会阻塞
        queue.put(i)
    print("test_queue_write子进程：所有数据都已写入了队列中")


def test_queue_read(queue):
　　# 从队列中取出数据
    while True:
        # 判断队列是否为空
        if not queue.empty():
            print(queue.get())
        else:
            break


def test_multi():
    # 创建一个子进程，并将需要执行的目标函数使用target参数进行传递
    p = multiprocessing.Process(target=multi_1)

    # args：给固定参数传参，最后必须带一个逗号 "，"  kwargs：给命名参数传参
    p_2 = multiprocessing.Process(target=multi_2, args=(os.getpid(), ), kwargs={"name": "xienuo"})

    # p 子进程 守护主进程,当主进程执行完成以后，主进程不会等待 p 子进程
    # p.daemon = True

    # 启动子进程，默认情况主进程会守护所有子进程，等所有子进程运行结束后，才会退出
    p.start()
    p_2.start()

    # 主进程执行完毕，直接销毁 p 子进程,不管子进程是否已执行完毕，和daemon具有相似的功能
    # p.terminate()

    # 等待 p 子进程结束后再执行下一步
    # p.join()
    # 等待 p_2 子进程结束后再执行下一步
    # p_2.join()

    # 父进程创建Queue，并传给各个子进程,可以设置队列的上限，不设置则表示没有上限
    q = Queue()
    pw = multiprocessing.Process(target=test_queue_write, args=(q,))
    pr = multiprocessing.Process(target=test_queue_read, args=(q,))

    pw.start()
    # 这里设置成了让写操作先完成, 再进行读操作(阻塞），这样设置的话其实就相当于是同步执行，影响了性能
    pw.join()
    pr.start()

    print("默认情况下：主进程运行结束，会等待子进程")


test_multi()