标签：__ job2 job1 Python threading 线程 print 多线程

介绍

在Python中，使用多线程multi-threading可以『同时』执行多个任务，比如你需要一个线程来复制读取信息，另一个线程来解析。为什么这里的同时要加引号呢，这是由于Python中GIL，也就是全局锁，看似同时执行多个任务，实际上是分布执行的，只不过各自完成不同的任务会提高工作效率。如果你不了解GIL，请看下图

实例教程

实例1

import threading

def job():
    info = "this is an added thread, which is %s" % threading.current_thread
    print(info)

def main():
    print(threading.active_count())
    print(threading.enumerate())
    #print(threading.current_thread())

    # 创建一个Thread对象，让他来复制job任务
    new_thread = threading.Thread(target=job)
    # 执行线程任务
    new_thread.start()
    print(threading.active_count())

if __name__ == '__main__':
    main()

运行结果：

1
[<_MainThread(MainThread, started 140637982934784)>]
this is an added thread, which is <function current_thread at 0x7fe8cd92d378>
2

解释一下：

1. threading是线程模块，需要导入
2. threading.active_count()方法会给出所有激活的线程数量
3. threading.enumerate()方法会列举出存在的每一个线程
4. threading.current_thread()方法会给出当前正在执行的线程
5. 使用时需要先创建线程对象，并指定任务（target），然后用start方法来执行

实例2

import threading
import time

def job():
    print('T1 start\n')
    # 让任务延迟一下
    for i in range(10):
        time.sleep(0.1)
    print('T1 finish\n')

def job2():
    print('T2 start\n')
    # 任务不延迟
    print('T2 finish\n')

def main():
    thread1 = threading.Thread(target=job,name='T1')
    thread2 = threading.Thread(target=job2,name='T2')
    thread1.start()
    thread2.start()

    #thread1.join()

    print('all done')

if __name__ == '__main__':
    main()

运行结果：

T1 start

T2 start

T2 finish

all done
T1 finish

会发现all done并不是在最后执行的，怎么办呢？试试把join方法解除封（注）印（释），请看结果：

T1 start

T2 start

T2 finish

T1 finish

all done

解释一下：

1. 多个线程是交叉进行的
2. join方法可以用来等待该线程完成任务

实例3

import threading
from queue import Queue
import time

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

    q.put(l)


def multithreading(data):
    q = Queue()
    threads = []
    THREAD_NUM = 4
    for i in range(THREAD_NUM):
        t = threading.Thread(target=job,args=(data[i],q))
        t.start()
        threads.append(t)
    for t in threads:
        t.join()
    results = []
    for _ in range(THREAD_NUM):
        results.append(q.get())

    print(results)

def unithreading(data):
    for i in range(len(data)):
        l = data[i]
        for j in range(len(l)):
            data[i][j] = data[i][j]**2

    print(data)

if __name__ == '__main__':
    data1 = [[1],[2,3],[4,5,6],[7,8,9,10]]
    data2 = [[1],[2,3],[4,5,6],[7,8,9,10]]
    time1 = time.clock()
    unithreading(data1)
    time2 = time.clock()
    multithreading(data2)
    time3 = time.clock()

    runtime_uni = time2 - time1
    runtime_multi = time3 - time2

    print("Runtime for unithreading is %s seconds." % runtime_uni)
    print("Runtime for multithreading is %s seconds." % runtime_multi)

运行结果：

[[1], [4, 9], [16, 25, 36], [49, 64, 81, 100]]
[[1], [4, 9], [16, 25, 36], [49, 64, 81, 100]]
Runtime for unithreading is 4.300000000000137e-05 seconds.
Runtime for multithreading is 0.001118000000000001 seconds.

解释一下：

1. 这个例子主要是对比一下单线程是多线程的速度
2. 这里演示了如何创建多个线程（此处为4个），并且分别执行任务
3. 因为线程任务本身是没有return的，所以顺便学习一下队列queue的用法，以及put和get方法

实例4

import threading


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

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

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

运行结果：

job1job2  111

job1job2  1222

job1job2  2333

job1job2  3444

job1job2  4555

job1job2  5666

job1job2  6777

job1job2  7888

job1job2  8999

job1job2  100110

你会发现这打印得错乱了，这也是多个线程交替工作得原因，如果先想要规定一个线程工作的时候防止别的线程干扰，需要怎么做呢？试试使用lock（注释部分）吧，再运行一下：

job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 10
job2 20
job2 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110

解释一下：

1. lock可以用来锁住一个线程，放置别的线程干扰它
2. acquire方法和release方法分别是用来加锁和解锁的

最后

多线程的简单应用就到这里，我们最开始说过由于GIL，Python得多线程并不是真正的去同时执行多个任务，那么有没有办法弥补呢？有，那就是多进程！你一定听说过多核吧，下次再讲：）

标签：__,job2,job1,Python,threading,线程,print,多线程
来源： https://www.cnblogs.com/mrdoghead/p/12121416.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。