初识python：多线程

多线程：在一个程序中，独立运行的程序片断叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。即：一个进程中，多个线程。

举个例说明：就像是一列火车就是一个“进程”（程序），火车的每一节车厢就是一个“线程”。每个线程可以独立的做一些事情。

python 中 threading 模块提供了多线程编程方法。

threading.enumerate() 查看当前线程的数量

threading.current_thread() 查看当前线程的信息

下面通过两种方式加以说明“多线程”模式。

功能：运行两个“功能”，一个“写”，一个“画”。

一、传统方式

def coding():
    for i in range(3):
        print('正在写入：',i)
        time.sleep(1)

def drawing():
    for i in range(3):
        print('正在画图：',i)
        time.sleep(1)

def main():
    coding()
    drawing()

if __name__ == '__main__':
    main()

执行结果： 一个一个执行，共耗时6s。

二、多线程方式

def coding():
    for i in range(3):
        print('正在写入：',i)
        print(threading.current_thread())  # 查看当前线程的名字
        time.sleep(1)

def drawing():
    for i in range(3):
        print('正在画图：',i)
        print(threading.current_thread())  # 查看当前线程的名字
        time.sleep(1)

# 多线程方式执行
def thread():
    t1 = threading.Thread(target=coding)  # 注意，此处target传入的是一个函数(coding就是一个函数)，不是函数的返回值(coding()是函数的返回值)
    t2 = threading.Thread(target=drawing)
    t1.start()
    t2.start()
    print(threading.enumerate())  # 查看当前线程数量 # [<_MainThread(MainThread, started 7020)>, <Thread(Thread-1, started 2088)>, <Thread(Thread-2, started 7516)>]

if __name__ == '__main__':
    thread()

执行结果：两个同时执行，共耗时3s。

由上对比，可以看出：多线程执行效率比传统单线程方式的执行效率高很多。

多线程 threading.Thread 类 方法

class CodingThread(threading.Thread):
    def run(self):
        for i in range(3):
            print('正在写入：', i)
            print(threading.current_thread())  # 查看当前线程的名字
            time.sleep(1)

class DrawingThread(threading.Thread):
    def run(self):
        for i in range(3):
            print('正在画图：', i)
            print(threading.current_thread())  # 查看当前线程的名字
            time.sleep(1)

def main():
    t1 = CodingThread()
    t2 = DrawingThread()
    t1.start()
    t2.start()

if __name__ == '__main__':
    main()

执行结果：

多线程共享全局变量

多线程都是在同一个进程中运行的。因此在进程中的全局变量所有线程都是可共享的。这就造成了一个问题，因为线程执行的顺序是无序的。有可能会造成数据错误。比如以下代码：

VALUE = 0  # 定义全局变量
def add_value():
    global VALUE  # 指定是一个全局变量
    for i in range(1000000):
        VALUE += 1  # 修改全局变量值
    print(VALUE)

# 使用线程方式执行，两个线程同时执行 add_value
def main():
    for x in range(2):
        t = threading.Thread(target=add_value)
        t.start()

if __name__ == '__main__':
    main()

执行结果：

锁机制：

变量名 = threading.Lock() # 创建锁

acquire() # 加锁

release() # 解锁

为了解决以上使用共享全局变量的问题。threading提供了一个Lock类，这个类可以在某个线程访问某个变量的时候加锁，其他线程此时就不能进来，直到当前线程处理完后，把锁释放了，其他线程才能进来处理。示例代码如下：

VALUE = 0  # 定义全局变量

# 创建锁
gLock = threading.Lock()

def add_value():
    global VALUE  # 指定是一个全局变量
    gLock.acquire()  # 加锁
    for i in range(1000000):
        VALUE += 1  # 修改全局变量值
    gLock.release()  # 解锁
    print(VALUE)

# 使用线程方式执行
def main():
    for x in range(2):
        t = threading.Thread(target=add_value)
        t.start()

if __name__ == '__main__':
    main()

执行结果：