Python多线程函数：学习这十个提高程序性能

Python是一门开源的高级编程语言，越来越多的开发人员将其用于各种应用程序的开发。在Python中，多线程可以帮助我们更好的利用CPU，充分发挥其性能，在处理I/O密集型任务方面表现尤为出色。在这篇文章中，我们将介绍十个常用的Python多线程函数，这些函数可以提高程序性能和效率，也会让开发更加轻松。

1. threading.Thread(target, args)

这是Python中创建线程的最基本方式。通过创建Thread类的实例，我们可以定义执行的目标函数或方法，并使用args传递参数。然后，我们可以通过调用start()方法启动线程。

示例代码：

import threading

def worker(num):
    print('Worker: %s' % num)

for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    t.start()

2. threading.active_count()

此函数返回当前活动的线程数。

示例代码：

import threading
import time

def worker():
    print('Worker thread started')
    time.sleep(2)
    print('Worker thread finished')

threads = []
for i in range(5):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

print('Active threads:', threading.active_count())

输出：

Worker thread started
Worker thread started
Worker thread started
Worker thread started
Worker thread started
Active threads: 5
Worker thread finished
Worker thread finished
Worker thread finished
Worker thread finished
Worker thread finished

3. threading.current_thread()

此函数返回当前运行的线程实例。

示例代码：

import threading

def worker():
    print('Current thread:', threading.current_thread().name)

t1 = threading.Thread(target=worker, name='Worker A')
t2 = threading.Thread(target=worker, name='Worker B')

t1.start()
t2.start()

输出：

Current thread: Worker A
Current thread: Worker B

4. threading.enumerate()

此函数返回当前所有活动的线程列表。

示例代码：

import threading
import time

def worker():
    print('Worker thread started')
    time.sleep(2)
    print('Worker thread finished')

threads = []
for i in range(3):
    t = threading.Thread(target=worker, name='Worker %s' % i)
    threads.append(t)
    t.start()

for t in threading.enumerate():
    if t != threading.current_thread():
        print('Joining:', t.getName())
        t.join()

print('Active threads:', threading.active_count())

输出：

Worker thread started
Worker thread started
Worker thread started
Worker 0
Worker 1
Worker 2
Worker thread finished
Worker thread finished
Worker thread finished
Active threads: 1

5. threading.Timer(interval, function, args)

此函数开启一个计时器，制定一个时间间隔后执行给定的函数，args可以传递参数。

示例代码：

import threading

def hello(name):
    print('Hello, %s!' % name)

t = threading.Timer(5.0, hello, args=('World',))
t.start()

输出：

Hello, World!

6. threading.Event()

此函数创建一个事件对象，支持线程之间的通信，例如，一个线程可以等待另一个线程发出信号以后再继续执行。

示例代码：

import threading

def worker(evt):
    print('Waiting for event')
    evt.wait()
    print('Event occurred')

evt = threading.Event()
t = threading.Thread(target=worker, args=(evt,))
t.start()

evt.set()  # 事件触发

输出：

Waiting for event
Event occurred

7. threading.Lock()

在多线程环境中，线程不加锁的情况下访问共享变量可能会导致数据不一致。此函数创建一个锁对象，线程在访问共享变量之前需要获取锁，使用完之后需要释放锁。

示例代码：

import threading
import time

balance = 0
lock = threading.Lock()

def deposit(amount):
    global balance
    lock.acquire()
    try:
        balance += amount
        print('Depositing, balance: %s' % balance)
    finally:
        lock.release()

def withdraw(amount):
    global balance
    lock.acquire()
    try:
        balance -= amount
        print('Withdrawing, balance: %s' % balance)
    finally:
        lock.release()

t1 = threading.Thread(target=deposit, args=(100,))
t2 = threading.Thread(target=withdraw, args=(50,))
t1.start()
t2.start()

t1.join()
t2.join()

print('Final balance:', balance)

输出：

Depositing, balance: 100
Withdrawing, balance: 50
Final balance: 50

8. threading.Condition()

此函数创建一个条件变量，它包含了一个锁和信号。线程在访问共享变量之前需要获取锁并监视信号，使用完之后需要释放锁并通知其他线程。

示例代码：

import threading

condition = threading.Condition()
queue = []

def producer():
    for i in range(5):
        condition.acquire()
        queue.append(i)
        print('Producing:', i)
        condition.notify()
        condition.release()

def consumer():
    while True:
        condition.acquire()
        while not queue:
            condition.wait()
        i = queue.pop(0)
        print('Consuming:', i)
        condition.release()

t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)

t1.start()
t2.start()

输出：

Producing: 0
Consuming: 0
Producing: 1
Consuming: 1
Producing: 2
Consuming: 2
Producing: 3
Consuming: 3
Producing: 4
Consuming: 4

9. threading.Semaphore()

此函数创建一个信号量对象，它限制了同时访问共享资源的线程数。

示例代码：

import threading

max_workers = 3
semaphore = threading.Semaphore(max_workers)

def worker(num):
    with semaphore:
        print('Worker', num)

for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    t.start()

输出：

Worker 0
Worker 2
Worker 3
Worker 1
Worker 4

10. concurrent.futures.ThreadPoolExecutor()

此函数创建一个线程池，它支持通过submit()方法提交任务，支持异步执行多个任务，支持等待所有任务完成。

示例代码：

import concurrent.futures
import time

def worker(num):
    print('Worker', num)
    time.sleep(2)
    return num * 10

with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(worker, i) for i in range(5)]

    for f in concurrent.futures.as_completed(futures):
        print('Result:', f.result())

print('All tasks completed')

输出：

Worker 0
Worker 1
Worker 2
Result: 0
Worker 3
Result: 10
Worker 4
Result: 20
Result: 30
Result: 40
All tasks completed

总结：

这十个Python多线程函数可以帮助我们更好的利用CPU，提高程序性能和效率，在处理I/O密集型任务方面表现尤为出色。在实际的开发过程中，我们需要根据任务的复杂度和性质选择合适的函数进行使用，提高程序的性能和可读性。