Python 多進程寫入同一文件

一、Python 多進程日誌寫入同一文件

在使用 Python 進行開發時，通常需要記錄程序運行過程中的日誌信息，而日誌寫入文件是最常見的方式。在多進程運行的情況下，如果多個進程都要寫入同一個文件，就需要考慮並發寫入的問題。

解決多進程寫入同一文件的方案一般有：

1. 使用共享鎖（Lock），讓進程互斥的訪問文件，避免並發寫入。

2. 讓所有進程共享一個文件標識符（File Descriptor），通過文件描述符的重定向，實現並發寫入。

import logging
from logging.handlers import RotatingFileHandler
import multiprocessing

def worker():
    logger = multiprocessing.get_logger()
    logger.setLevel(logging.INFO)
    
    file_handler = RotatingFileHandler(filename='example.log')
    file_handler.setLevel(logging.INFO)
    
    logger.addHandler(file_handler)
    
    logger.info('Hello, world!')

if __name__ == '__main__':
    logging.basicConfig(filename='example.log')
    logger = multiprocessing.get_logger()
    logger.setLevel(logging.INFO)
    
    processes = []
    for i in range(10):
        p = multiprocessing.Process(target=worker)
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()

二、Python 多進程讀寫文件

Python 的 multiprocessing 模塊可以很方便的創建多線程和多進程應用。多進程讀寫文件時，需要注意進程之間的同步問題。

對於一個進程，它打開一個文件後，系統會為它分配一個文件指針，指向文件的開頭位置。每次讀寫文件時，文件指針都會被移動到下一個位置。如果兩個進程同時寫入一個文件，它們會互相覆蓋對方的寫入內容，導致數據丟失。因此，需要使用共享鎖控制文件寫入。

import multiprocessing
import os

def write_file(file_path, data, lock):
    with lock:
        with open(file_path, 'a+') as f:
            f.write(data)        

def read_file(file_path):
    with open(file_path, 'r') as f:
        content = f.read()
    return content

if __name__ == '__main__':
    processes = []
    lock = multiprocessing.Lock()
    for i in range(10):
        p = multiprocessing.Process(target=write_file, args=('example.txt', 'Hello, world!\n', lock))
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()
    
    content = read_file('example.txt')
    print(content)

三、Python 多進程處理文件

Python 中使用多進程處理文件時，需要避免多個進程同時讀寫同一個文件，避免數據衝突。一種解決方法是將文件拆分成多個小文件，由每個進程分別處理，最後再將結果組合起來。

import os
import multiprocessing

def process_file(file_path):
    process_id = os.getpid()
    with open(file_path, 'r') as f:
        lines = f.readlines()
    result = [f'Process {process_id}: {line.upper()}' for line in lines]
    
    with open(f'output_{process_id}.txt', 'w') as f:
        f.writelines(result)

if __name__ == '__main__':
    file_path = 'example.txt'
    p1 = multiprocessing.Process(target=process_file, args=(file_path,))
    p2 = multiprocessing.Process(target=process_file, args=(file_path,))
    
    p1.start()
    p2.start()
    
    p1.join()
    p2.join()
    
    with open('output_{}.txt'.format(p1.pid), 'r') as f:
        content1 = f.read()
    with open('output_{}.txt'.format(p2.pid), 'r') as f:
        content2 = f.read()
    
    print(content1 + content2)

四、Python 多進程讀取同一個文件

在 Python 中讀取同一個文件可以通過 mmap 模塊映射到內存中讀取，即將文件映射到虛擬內存中，然後將內存中的數據讀取出來。

import os
import mmap
import multiprocessing

def process_file(file_path):
    with open(file_path, 'r') as f:
        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ) as m:
            content = m.readline()
    return content

if __name__ == '__main__':
    file_path = 'example.txt'
    p1 = multiprocessing.Process(target=process_file, args=(file_path,))
    p2 = multiprocessing.Process(target=process_file, args=(file_path,))
    
    p1.start()
    p2.start()
    
    p1_pid = p1.pid
    p2_pid = p2.pid
    
    p1.join()
    p2.join()
    
    content1 = process_file(file_path)
    content2 = process_file(file_path)
    
    print(f'Process {p1_pid}: {content1}')
    print(f'Process {p2_pid}: {content2}')

五、Python 多進程通信

多進程之間通信可以使用 Python 的 Queue 模塊。Queue 支持多線程和多進程，並且線程/進程安全，也支持多個進程同時讀寫。

import multiprocessing

def producer(queue, data):
    for item in data:
        queue.put(item)

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(item)

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    
    data = ['a', 'b', 'c', 'd', 'e']
    
    p1 = multiprocessing.Process(target=producer, args=(queue, data))
    p2 = multiprocessing.Process(target=consumer, args=(queue,))
    
    p1.start()
    p2.start()
    
    p1.join()
    
    queue.put(None)
    
    p2.join()

以上就是 Python 多進程寫入同一文件的相關內容，包括多進程日誌寫入同一文件，多進程讀寫文件，多進程處理文件，多進程讀取同一個文件，以及多進程通信等方面。