multithreading基础

多线程

主要是记住几个函数，threading.active_count(),threading.enumerate(),threading.current_thread()。新建一个线程是threading.Thread()，其中参数target不能是一个函数，应该传一个函数名，如果要传数据，使用args参数。

# -*- coding:utf-8 -*-
import threading

# 添加一个线程 并且为其指定工作
import time


def add_thread_job():
    print('I am the new job,my task is print %s' % threading.current_thread().name)


def thread2_job():
    print('thread2 is start')
    for i in range(0, 10):
        time.sleep(0.1)
    print('thread2 is finish')


def main():
    added_thread = threading.Thread(target=add_thread_job)
    thread2 = threading.Thread(target=thread2_job)
    added_thread.start()
    thread2.start()
    thread2.join()
    print('all done\n')


if __name__ == '__main__':
    main()

队列

其实这里我省略了，每个added_thread都可以append到一个threads的列表里，然后对这个列表遍历。感觉没实际意义。

# -*- coding:utf-8 -*-
import threading
from queue import Queue


def thread_job(l, q):
    for i in range(len(l)):
        l[i] = l[i] ** 2
    q.put(l)


def queue_thread():
    q = Queue()
    data = [[1, 2, 3], [4, 5, 6]]
    for i in range(len(data)):
        added_thread = threading.Thread(target=thread_job, args=(data[i], q))
        added_thread.start()
        added_thread.join()
    results = []
    for _ in range(len(data)):
        results.append(q.get())
    print(results)


if __name__ == '__main__':
    queue_thread()

Lock

# -*-coding:utf-8 -*-
import threading

"""
为了让一个线程完成后，另一个线程才开始运行，使用lock锁住要先完成的线程
"""


def job1():
    global A, lock
    lock.acquire()
    for _ in range(10):
        A += 1
        print('job1:', A)
    lock.release()


def job2():
    global A, lock
    lock.acquire()
    for _ in range(10):
        A += 10
        print('job2:', A)
    lock.release()


if __name__ == '__main__':
    lock = threading.Lock()
    A = 0
    added_thread1 = threading.Thread(target=job1)
    added_thread2 = threading.Thread(target=job2)
    added_thread1.start()
    added_thread2.start()
    added_thread1.join()
    added_thread2.join()

GIL 全局锁问题

尽管Python完全支持多线程编程， 但是解释器的C语言实现部分在完全并行执行时并不是线程安全的。 实际上，解释器被一个全局解释器锁保护着，它确保任何时候都只有一个Python线程执行。 GIL最大的问题就是Python的多线程程序并不能利用多核CPU的优势 （比如一个使用了多个线程的计算密集型程序只会在一个单CPU上面运行）。

赏

谢谢你倾听我!