Python并行编程(二)：基于线程的并行

时间：2024-01-07 14:32:38

1、介绍

软件应用中使用最广泛的并行编程范例是多线程。通常一个应用有一个进程，分成多个独立的线程，并行运行、互相配合，执行不同类型的任务。

线程是独立的处理流程，可以和系统的其他线程并行或并发地执行。多线程可以利用共享内存空间共享数据和资源。线程和进程的具体实现取决于你要运行的操作系统，但是总体来讲，我们可以说线程是包含在进程中的，同一个进程的多个不同的线程可以共享相同的资源，而进程之间不会共享资源。

每一个线程基本上包含3个元素：程序计数器，寄存器和栈。与同一进程的其他线程共享的资源基本上包括数据和系统资源。每一个线程也有自己的运行状态，可以和其他线程同步，线程的状态大体上可以分为ready,running,blocked。线程的典型应用是应用软件的并行化，目的是为了充分利用现代的多核处理器，使每个核心可以运行单个线程。相比于进程，使用线程的优势主要是性能，相比之下，在进程之间切换上下文要比在统一进程的多线程之间切换上下文要重的多。

2、定义一个线程

使用线程最简单的方式是用一个目标函数实例化一个Thread然后调用start()方法启动它。Python的threading模块提供了Thread()方法在不同的线程中运行函数或处理过程等。

class threading.Thread(group=None,  target=None, name=None, args=(), kwargs={})

- group：特性预留

- target：当线程启动的时候要执行的函数

- name：线程的名字，默认为Thread-N

- args：传递给target的参数，要试用tuple类型

- kwargs：同上，试用字段类型dict

线程代码用例：

import threading

def function(i):

    print("I am thread-%s" %i)

    return

threads = []

for i in range(5):

    t = threading.Thread(target=function, args=(i,))

    threads.append(t)

    t.start()

    t.join()

t.join：主线程会调用t线程，然后等待t线程完成再执行for循环开启下一个t线程。可理解为阻塞主线程。

3、确认一个线程

使用参数来确认或命名线程是没有必要的，每一个Thread实例创建的时候都有一个带默认值的名字，并且可以修改。在服务端通常一个服务进程都有多个线程服务，负责不同的操作，这时候命名线程是很实用的。

自定义线程名称用例：

import threading

import time

def first_function():

    print("%s is starting" %threading.currentThread().getName())

    time.sleep(2)

    print("%s is exiting" %threading.currentThread().getName())

def second_function():

    print("%s is starting" %threading.currentThread().getName())

    time.sleep(2)

    print("%s is exiting" %threading.currentThread().getName())

def third_function():

    print("%s is starting" %threading.currentThread().getName())

    time.sleep(2)

    print("%s is exiting" %threading.currentThread().getName())

if __name__ == "__main__":

    t1 = threading.Thread(name='first_function', target=first_function)

    t2 = threading.Thread(name='second_function', target=second_function)

    t3 = threading.Thread(name='third_function', target=third_function)

    t1.start()

    t2.start()

    t3.start()

    t1.join()

    t2.join()

    t3.join()

运行结果：

Python并行编程(二)：基于线程的并行

如果不自定义名称如下：

import threading

import time

def first_function():

    print("%s is starting" %threading.currentThread().getName())

    time.sleep(2)

    print("%s is exiting" %threading.currentThread().getName())

def second_function():

    print("%s is starting" %threading.currentThread().getName())

    time.sleep(2)

    print("%s is exiting" %threading.currentThread().getName())

def third_function():

    print("%s is starting" %threading.currentThread().getName())

    time.sleep(2)

    print("%s is exiting" %threading.currentThread().getName())

if __name__ == "__main__":

    # t1 = threading.Thread(name='first_function', target=first_function)

    # t2 = threading.Thread(name='second_function', target=second_function)

    # t3 = threading.Thread(name='third_function', target=third_function)

    t1 = threading.Thread(target=first_function)

    t2 = threading.Thread(target=second_function)

    t3 = threading.Thread(name='third_function', target=third_function)

    t1.start()

    t2.start()

    t3.start()

    t1.join()

    t2.join()

    t3.join()

运行结果：

Python并行编程(二)：基于线程的并行

4、使用线程

在子类中实现线程：

import threading

import time

exit_flag = 0

class myThread(threading.Thread):

    def __init__(self, threadID, name, counter):

        threading.Thread.__init__(self)

        self.threadID = threadID

        self.name = name

        self.counter = counter

    def run(self):

        print("Starting %s" %self.name)

        print_time(self.name, self.counter, 5)

        print("Exiting %s" %self.name)

def print_time(threadName, delay, counter):

    while counter:

        if exit_flag:

            import _thread

            _thread.exit()

        time.sleep(delay)

        print("%s:%s" %(threadName, time.ctime(time.time())))

        counter -= 1

# 创建实例

thread1 = myThread(1, "Thread-1", 1)

thread2 = myThread(2, "Thread-2", 2)

thread1.start()

thread2.start()

thread1.join()

thread2.join()

print("Exiting Main Thread")

运行结果如下：

Python并行编程(二)：基于线程的并行

线程模块是创建和管理线程的首选形式。每一个线程都通过一个集成Thread的子类代表，覆盖run()方法来实现逻辑，这个方法是线程的入门，执行start()即调用此方法。

相关文章