Python中多线程thread与threading的实现方法

Python提供了两个模块来实现多线程，分别是thread和threading。其中，thread是低级模块，它提供了基本的线程功能。而threading是高级模块，它借鉴了Java中线程的概念，提供了更加高级、更加便捷的线程管理方式。下面分别介绍这两个模块的实现方法。

thread模块的实现方法

线程的创建

使用thread模块创建线程的方法很简单，只需要调用start_new_thread()函数即可。这个函数的用法如下：

thread.start_new_thread(function, args[, kwargs])

其中，function是一个可调用对象（function、方法、lambda表达式等），用来表示线程要执行的任务；args是一个元组，用来传递参数给函数；kwargs是一个字典，用来传递关键字参数给函数。示例如下：

import thread
import time

def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s" % (threadName, time.ctime(time.time())))

try:
    thread.start_new_thread(print_time, ("Thread-1", 2,))
    thread.start_new_thread(print_time, ("Thread-2", 4,))
except:
    print("Error: 无法启动线程")

这个示例中，我们定义了一个叫作print_time()的函数，它会在延迟一定时间后打印出当前的时刻。然后，我们分别用start_new_thread()创建了两个线程，分别执行了这个函数。

线程的同步

多个线程访问同一个资源时，可能会发生冲突。为了避免这种情况的发生，我们需要对线程进行同步。Python中提供了threading.Lock()函数来实现线程同步。用法如下：

import thread
import threading
import time

class Counter:
    def __init__(self):
        self.value = 0
        self.lock = threading.Lock()

    def increment(self):
        self.lock.acquire()
        self.value += 1
        print("Counter: %d" % self.value)
        self.lock.release()

def worker(c):
    for i in range(5):
        time.sleep(0.1)
        c.increment()

c = Counter()
for i in range(10):
    thread.start_new_thread(worker, (c,))

time.sleep(1)

在这个示例中，我们定义了一个Counter类，它包含一个值和一个锁。在increment()方法中，我们先获取锁，然后增加值并打印，最后释放锁。在worker()方法中，我们用一个循环来五次调用increment()方法来增加值。接着我们创建了十个线程，分别执行worker()方法。当所有线程执行结束后，我们再等待一秒钟，让缓冲区中的内容输出完成。

threading模块的实现方法

线程的创建

使用threading模块创建线程的方法较为简单，只需要创建一个Thread类的实例，并将要执行的任务作为参数传入，然后调用start()方法即可。示例如下：

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay

    def run(self):
        print("开始线程：" + self.name)
        print_time(self.name, self.delay)
        print("结束线程：" + self.name)

def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s" % (threadName, time.ctime(time.time())))

thread1 = MyThread(1, "Thread-1", 2)
thread2 = MyThread(2, "Thread-2", 4)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

在这个示例中，我们首先定义了一个MyThread类，它继承自Thread类。在MyThread类的构造方法中，我们定义了线程ID、线程名字和延迟时间。然后，在run()方法中，我们调用了print_time()函数，将线程名字和延迟时间传入。最后，我们创建了两个线程，分别执行了MyThread类的实例。

线程的同步

使用threading模块实现线程同步主要是通过Lock、RLock、Semaphore、Event和Condition等类来实现的。我们以Lock类为例说明线程同步的实现方法。示例如下：

import threading

class Counter:
    def __init__(self):
        self.value = 0
        self.lock = threading.Lock()

    def increment(self):
        with self.lock:
            self.value += 1
            print("Counter: %d" % self.value)

def worker(c):
    for i in range(5):
        c.increment()

c = Counter()
threads = []
for i in range(10):
    t = threading.Thread(target=worker, args=(c,))
    threads.append(t)

for t in threads:
    t.start()

for t in threads:
    t.join()

在这个示例中，我们定义了一个Counter类，它和前面的示例一样，包含一个值和一个锁。在increment()方法中，我们使用了with语句，来自动获取和释放锁。在worker()方法中，我们依然用一个循环来五次调用increment()方法来增加值。然后，我们创建了十个线程，分别执行worker()方法。

以上就是markdown格式的Python中多线程thread与threading的实现方法完整攻略。