Python多线程处理实例详解【单进程/多进程】

什么是多线程？

• 在操作系统中，进程是分配资源的基本单位，而线程则是进程中执行代码的单位。
• 一个进程中可以包含多个线程，每个线程共享进程的内存和资源，但是每个线程也有各自的执行堆栈和局部变量，从而实现并发执行。

Python中的多线程实现

• Python中使用threading模块实现多线程。
• 使用Thread类可以创建一个线程对象，执行这个线程对象的start()方法可以创建并开始一个线程。

下面是创建一个简单线程的示例：

import threading

def print_time(thread_name, counter, delay):
    while counter > 0:
        print("%s: %s" % (thread_name, time.ctime(time.time())))
        time.sleep(delay)
        counter -= 1

thread1 = threading.Thread(target=print_time, args=("Thread-1", 5, 1))
thread2 = threading.Thread(target=print_time, args=("Thread-2", 5, 2))

thread1.start()
thread2.start()

# 等待线程结束
thread1.join()
thread2.join()

print("Exit main thread")

上述代码创建了两个线程，分别是Thread-1和Thread-2，每个线程都会执行print_time函数，并且传入不同的参数。在创建线程后，分别通过start()方法启动线程，最后通过join()方法等待线程结束。

线程的同步和通信

在多线程编程中，为了防止线程之间对同一共享资源的争用而出现的问题，通常会使用线程同步和线程通信方式。

线程同步

• 线程同步是指在多个线程间，按照一定顺序对共享资源的访问，以避免数据不一致或者发生冲突等问题。
• 在Python中，可以使用Lock、RLock、Semaphore等锁机制来实现线程同步。

下面是一个简单的使用Lock实现线程同步的示例：

import threading

count = 0
lock = threading.Lock()

def add_count():
    global count, lock

    for i in range(100000):
        lock.acquire()
        count += 1
        lock.release()

thread1 = threading.Thread(target=add_count)
thread2 = threading.Thread(target=add_count)

thread1.start()
thread2.start()

# 等待线程结束
thread1.join()
thread2.join()

print("Final count: %s" % count)

在上述示例中，count是共享资源，我们使用Lock来同步两个线程对count的访问，保证了count的递增过程是安全的。

线程通信

• 线程通信是指在多个线程间，通过同步的方式来传递信息，从而实现线程之间的协调和同步。
• 在Python中，可以使用queue队列实现线程通信。

下面是一个简单的使用queue实现线程通信的示例：

import queue
import threading
import time

queue1 = queue.Queue(10)

def produce():
    for i in range(10):
        queue1.put(i)
        print("produce %s" % i)
        time.sleep(1)

def consume():
    while True:
        item = queue1.get()
        if item is None:
            break
        print("consume %s" % item)

thread1 = threading.Thread(target=produce)
thread2 = threading.Thread(target=consume)

thread1.start()
thread2.start()

thread1.join()
queue1.put(None)
thread2.join()

在上述示例中，我们创建了一个队列queue1，生产线程produce向队列中添加数据，消费线程consume从队列中获取数据并输出，通过这种方式实现了多线程之间的通信和同步。

多进程处理

多进程是指在操作系统中并行执行多个进程的方式，同一个程序可以通过多个进程来同时执行多个任务。

Python中的多进程实现

在Python中，我们可以使用multiprocessing模块实现多进程处理。

下面是一个简单的使用Process类创建多进程的示例：

import multiprocessing
import time

def worker():
    print("%s start" % multiprocessing.current_process().name)
    time.sleep(2)
    print("%s end" % multiprocessing.current_process().name)

if __name__ == '__main__':
    process1 = multiprocessing.Process(name='process1', target=worker)
    process2 = multiprocessing.Process(name='process2', target=worker)

    process1.start()
    process2.start()

    process1.join()
    process2.join()

    print("All subprocess(es) have finished")

在上述示例中，我们通过创建Process类的对象，使用start()方法启动多个进程，最后使用join()方法等待进程结束。

多进程池

在多进程处理中，由于进程的创建和销毁都会消耗额外的资源，因此创建多个进程比较浪费资源，为此我们可以使用多进程池。

使用多进程池可以有效地减少进程的创建和销毁次数，节省了系统资源，提高了进程的执行效率。

下面是一个简单的使用Pool类创建多进程池的示例：

import multiprocessing
import time

def worker(n):
    print("%s start with %s" % (multiprocessing.current_process().name, n))
    time.sleep(2)
    print("%s end with %s" % (multiprocessing.current_process().name, n))
    return n*2

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=2)

    results = []
    for i in range(5):
        results.append(pool.apply_async(worker, (i,)))

    pool.close()
    pool.join()

    for r in results:
        print(r.get())

在上述示例中，我们通过创建Pool类的对象，使用apply_async()方法将多个任务交给进程池执行，并使用get()方法获取任务的结果。

总结

本文介绍了Python中多线程和多进程的基本概念和实现方式，并给出了涉及线程同步、线程通信和多进程池的示例代码。同时，多线程和多进程处理在Python中都得到了良好的支持，你可以根据实际需要选择适合的方式来实现多任务处理。