欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python 3 线程模型,进程模型记录

程序员文章站 2022-05-09 15:01:31
最近需要使用 python3 多线程处理大型数据,顺道探究了一下,python3 的线程模型的情况,下面进行简要记录; 多线程运行的优点: 使用线程可以把程序中占用时间较长的任务放到后台去处理; 用户界面可以更加吸引人,并且不阻塞界面的运行; 程序运行的速度可以更快; 充分利用CPU多核的特征进行处 ......

最近需要使用 python3 多线程处理大型数据,顺道探究了一下,python3 的线程模型的情况,下面进行简要记录;

多线程运行的优点:

  •  使用线程可以把程序中占用时间较长的任务放到后台去处理;
  • 用户界面可以更加吸引人,并且不阻塞界面的运行;
  • 程序运行的速度可以更快;
  • 充分利用cpu多核的特征进行处理;

内核线程:由操作系统内核创建和撤销;

用户线程:不需要内核支持在用户程序中实现的线程;

python3 中的多线程:

  • _thread 提供了一些原始的api 用于写多线程程序;
  • threading 提供了更加便利的接口
  • 两者都是python3内置的线程模块
#!/usr/bin/env python

import _thread

def print_time( threadname, delay):
    print (threadname)
    count = 0
    while 1:
        pass
        count += 1

try:
    _thread.start_new_thread( print_time, ("thread-1", 1, ) )
    _thread.start_new_thread( print_time, ("thread-2", 2, ) )
    _thread.start_new_thread( print_time, ("thread-3", 2, ) )
    _thread.start_new_thread( print_time, ("thread-4", 2, ) )
    _thread.start_new_thread( print_time, ("thread-5", 2, ) )
    _thread.start_new_thread( print_time, ("thread-6", 2, ) )
    _thread.start_new_thread( print_time, ("thread-7", 2, ) )
    _thread.start_new_thread( print_time, ("thread-8", 2, ) )
    _thread.start_new_thread( print_time, ("thread-9", 2, ) )
    _thread.start_new_thread( print_time, ("thread-10", 2, ) )
    _thread.start_new_thread( print_time, ("thread-11", 2, ) )
    _thread.start_new_thread( print_time, ("thread-12", 2, ) )
    _thread.start_new_thread( print_time, ("thread-13", 2, ) )
    _thread.start_new_thread( print_time, ("thread-14", 2, ) )
    _thread.start_new_thread( print_time, ("thread-15", 2, ) )

except:
    print ("error: can't start thread!")

while 1:
    pass
#!/usr/bin/env python3

import threading
import time

exitflag = 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 ("start" + self.name)
        print_time(self.name, self.counter, 5)
        print ("exit" + self.name)

def print_time(threadname, delay, counter):
    while counter:
        if exitflag:
            threadname.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 ("exit!")

python 的多线程 threading 有时候并不是特别理想. 最主要的原因是就是, python 的设计上, 有一个必要的环节, 就是 global interpreter lock (gil). 这个东西让 python 还是一次性只能处理一个东西:

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

gil只会影响到那些严重依赖cpu的程序(比如计算型的)。 如果你的程序大部分只会涉及到i/o,比如网络交互,那么使用多线程就很合适, 因为它们大部分时间都在等待;

import threading
from queue import queue
import copy
import time

def job(l, q):
    res = sum(l)
    q.put(res)

def multithreading(l):
    q = queue()
    threads = []
    for i in range(4):
        t = threading.thread(target=job, args=(copy.copy(l), q), name='t%i' % i)
        t.start()
        threads.append(t)
    [t.join() for t in threads]
    total = 0
    for _ in range(4):
        total += q.get()
    print(total)

def normal(l):
    total = sum(l)
    print(total)

if __name__ == '__main__':
    l = list(range(1000000))
    s_t = time.time()
    normal(l*4)
    print('normal: ',time.time()-s_t)
    s_t = time.time()
    multithreading(l)
    print('multithreading: ', time.time()-s_t)
#!/usr/bin/env python

import multiprocessing as mp
import threading as td

def job(a,b):
    while 1:
        pass

t1 = td.thread(target=job,args=(1,2))
t2 = td.thread(target=job,args=(1,2))
t3 = td.thread(target=job,args=(1,2))
t4 = td.thread(target=job,args=(1,2))
t5 = td.thread(target=job,args=(1,2))
t6 = td.thread(target=job,args=(1,2))
t7 = td.thread(target=job,args=(1,2))
t8 = td.thread(target=job,args=(1,2))
t9 = td.thread(target=job,args=(1,2))
t10 = td.thread(target=job,args=(1,2))
t11 = td.thread(target=job,args=(1,2))
t12 = td.thread(target=job,args=(1,2))
t13 = td.thread(target=job,args=(1,2))
t14 = td.thread(target=job,args=(1,2))
t15 = td.thread(target=job,args=(1,2))
t16 = td.thread(target=job,args=(1,2))
# p1 = mp.process(target=job,args=(1,2))
# p2 = mp.process(target=job,args=(1,2))
# p3 = mp.process(target=job,args=(1,2))
# p4 = mp.process(target=job,args=(1,2))
# p5 = mp.process(target=job,args=(1,2))
# p6 = mp.process(target=job,args=(1,2))
# p7 = mp.process(target=job,args=(1,2))
# p8 = mp.process(target=job,args=(1,2))
# p9 = mp.process(target=job,args=(1,2))
# p10 = mp.process(target=job,args=(1,2))
# p11 = mp.process(target=job,args=(1,2))
# p12 = mp.process(target=job,args=(1,2))
# p13 = mp.process(target=job,args=(1,2))
# p14 = mp.process(target=job,args=(1,2))
# p15 = mp.process(target=job,args=(1,2))
# p16 = mp.process(target=job,args=(1,2))

t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t6.start()
t7.start()
t8.start()
t9.start()
t10.start()
t11.start()
t12.start()
t13.start()
t14.start()
t15.start()
t16.start()
# p1.start()
# p2.start()
# p3.start()
# p4.start()
# p5.start()
# p6.start()
# p7.start()
# p8.start()
# p9.start()
# p10.start()
# p11.start()
# p12.start()
# p13.start()
# p14.start()
# p15.start()
# p16.start()
t1.join()
t2.join()
t3.join()
t4.join()
t5.join()
t6.join()
t7.join()
t8.join()
t9.join()
t10.join()
t11.join()
t12.join()
t13.join()
t14.join()
t15.join()
t16.join()
# p1.join()
# p2.join()
# p3.join()
# p4.join()
# p5.join()
# p6.join()
# p7.join()
# p8.join()
# p9.join()
# p10.join()
# p11.join()
# p12.join()
# p13.join()
# p14.join()
# p15.join()
# p16.join()

使用python multiprocess 包能够发挥多核cpu并行处理能力

  • multiprocess 接口和threading 使用的接口一样;

保持更新,转载请注明出处,更多内容请关注cnblogs.com/xuyaowen;

参考链接:

https://morvanzhou.github.io/tutorials/python-basic/threading/5-gil/ 

https://python3-cookbook.readthedocs.io/zh_cn/latest/c12/p09_dealing_with_gil_stop_worring_about_it.html