python多线程使用

一、简介

由于python2逐渐不被维护，以及python更优越的性能。后面介绍的python相关知识都是用python3版本写。

这里介绍python3的多线程相关知识，线程的创建使用threading包。

二、简单线程创建

简介线程的创建，先定义执行任务的函数，然后调用threading.Thread(target=say_hello, args=('one',))方法即可，

启动线程使用start()方法，线程等待执行结束使用join()方法。

实例如下：

import threading


# def say_hello(x):
#     print("%s say hello" % x)

def main():
    # 定义任务处理函数
    say_hello = lambda x: print("%s say hello" % x)
    # 创建线程,args是传递的参数
    thread_1 = threading.Thread(target=say_hello, args=('one',))
    # 启动线程
    thread_1.start()
    # 等待线程执行完成
    thread_1.join()


if __name__ == '__main__':
    main()

三、创建线程类

创建线程的另一种方式，定义线程类，线程类需继承threading.Thread，

同时定义 __init__方法，用于传递的初始化参数，另外定义run(self)方法，用于线程执行的操作。

实例如下：

import threading


# 创建线程类
class sayHelloThread(threading.Thread):

    # 指定线程需要的参数name
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    # 指定线程运行时的操作
    def run(self):
        print('%s say hello' % self.name)


def main():
    # 创建线程
    thread_1 = sayHelloThread('one')
    # 启动线程
    thread_1.start()
    # 等待线程执行完成
    thread_1.join()


if __name__ 

四、线程池创建

创建线程池使用threadpool.ThreadPool(n)，n表示线程池内的线程个数。

然后创建线程池要执行的任务，使用makeRequests(callable_, args_list, callback=None,exc_callback=_handle_thread_exception)方法，

包含执行的方法和参数列表。

线程的执行使用putRequest(self, request, block=True, timeout=None)方法。

等待线程池执行结束用wait()方法。

实例如下：

import threadpool


def say_hello(name):
    print('%s say hello' % str(name))


def main():
    # 创建线程池，指定线程数为4
    pool = threadpool.ThreadPool(4)
    # 指定任务参数列表,里面一个元素代表着一个任务需要的参数
    task_param_list = ['one', 'two', 'three', ['four_1', 'four_2']]
    # 创建任务列表
    task_list = threadpool.makeRequests(say_hello, task_param_list)
    # 任务在线程池中执行
    [pool.putRequest(x) for x in task_list]
    # 等待任务执行完成
    pool.wait()
    print("dispose finished")


if __name__ == '__main__':
    main()

五、线程锁

这里介绍下用于多线程同步的锁，threading.Lock()用于创建锁，lock.acquire()获取锁，lock.release()释放锁。

实例如下：

import threading

# 创建锁
lock = threading.Lock()

# 创建线程类
class sayHelloThread(threading.Thread):

    # 指定线程需要的参数
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    # 指定线程运行时的操作
    def run(self):
        # 获取锁
        lock.acquire()
        print('%s say hello' % self.name)
        # 释放锁
        lock.release()


def main():
    # 创建线程
    thread_1 = sayHelloThread('one')
    thread_2 = sayHelloThread('two')
    # 启动线程
    thread_1.start()
    thread_2.start()
    # 等待线程执行完成
    thread_1.join()
    thread_2.join()


if __name__ == '__main__':
    main()

六、线程安全的队列

另外介绍下线程安全的队列，用queue.Queue()创建，可加参数指定队列的最大个数。

queue.get()用于从队列取数据，queue.put(item)用于向队列放数据。

实例如下：

import threading
from queue import Queue
import time

# 创建线程安全的队列
queue = Queue(3)


# 定义生产者线程类
class producerThread(threading.Thread):
    # 指定线程需要的参数
    def __init__(self):
        threading.Thread.__init__(self)

    # 指定线程运行时的操作
    def run(self):
        index = 1
        while True:
            index += 1
            item = "item" + str(index)
            # 生产item放入队列queue中
            queue.put(item)
            print('%s produce : %s' % (threading.current_thread().getName(), item))
            time.sleep(1)


# 定义消费者线程类
class customerThread(threading.Thread):
    # 指定线程需要的参数
    def __init__(self):
        threading.Thread.__init__(self)

    # 指定线程运行时的操作
    def run(self):
        while True:
            # 从队列queue中取数据
            item = queue.get()
            print('%s consumer : %s' % (threading.current_thread().getName(), item))


def main():
    # 创建生产者线程
    producer = producerThread()
    customer = customerThread()
    # 启动消费者线程
    producer.start()
    customer.start()


if __name__ == '__main__':
    main()