python多线程编程

版权声明:转载的时候请注明转载路径~~~ https://blog.csdn.net/kellyseeme/article/details/51473552

1、多线程的发展背景

随着计算机的发展,无论是硬件还是软件都在快速的发展。

在最开始的时候,计算机都是只有一个cpu来进行指令控制和运算,程序执行的时候都是一个进程一个进程的运行,也就是顺序执行的方式,所有的进程都是排成一个队列,然后cpu取出其中的一个进程,然后运行。

在硬件发展的时候,慢慢发展为几颗cpu,并且发展出来了几核cpu,从而在一般的服务器上都是四核的,并且至少是两颗,从而在每次服务器进行处理的时候,都是进行多进程的处理,可能说一颗cpu处理一个进程的情况出现,从而在这个时候,程序也就发展了多进程多线程的概念,在一个进程中有多个线程,而一个程序又可以运行多个线程。


在多进程和多线程主要发展出来的目标,也就是提高计算的性能,从而在这里的编程就称之为多线程编程,multi threading。


2、 python中的多线程

在python中,多线程是存在的,但是和其他编程中的多线程是不一样的,也就是在一个进程中存在着多个线程,但是,很遗憾的是,在python中仅仅支持一个线程的运行,也就是说,在python中的多线程依旧像是单线程的运行。

在python中存在一个锁,也就是GIL,global interpreter lock,全局解释器锁,用来控制在同一时刻只有仅仅一个线程的运行。在python中,多线程的执行方式如下:


看到上面这种情况,也就是在一个进程里的确是可以有多个线程,但是同一时刻还是只有一个线程的运行,那么为什么还要使用多线程呢,用一个线程不就好了?


在python中,多线程的最好的处理的问题是对I/O密集型的操作,也就是说,在计算密集型的操作的时候,是不适合使用多线程的,因为在同一时刻,还是只有一个线程使用到cpu,但是I/O是阻塞的方式,从而python的多线程还是用在I/O操作上面,例如有大量用户的输入等IO操作。


如果是计算密集型的操作,那么在python中,更适合使用多进程的方式,在python中,使用多进程的时候,没有像线程锁的这种限制。


3、 进程和线程的区别

进程的英文表示为process,线程的英文表示为thread。

进程消耗的资源(主要是内存)比线程需要消耗的资源要多,进程具有自己独立的数据空间;而在线程中,线程都是存在于一个进程当中,从而所有的线程都是共享资源的,线程之间的数据通信很简单,而进程间的通信需要使用到IPC,inter process comminication,可能就要使用socket进行通信,线程之间的通信,可以使用一个数据结构的容器就可以进行通信,例如数据结构Queue,这个是一个先进先出的数据结构,可以用来线程之间的通信。


在运行程序的时候,操作系统管理进程,进程中存在线程,其实是进程管理线程,如果具有多个线程,那么主线程就会管理子线程,在运行程序的时候,最开始就是一个进程一个主线程,主线程会管理子线程。

在操作系统中,我们可以直接查询到进程号,也就是进程的PID,可以直接杀死一个进程,但是我们不能直接杀死一个线程,查询进程的id如下所示:

[root@python 521]# ps -ef|grep server |grep -v grep
root     10981  1677  0 00:28 pts/0    00:00:00 python server.py

在其中pid为10981,从而可以使用kill命令直接杀死进程,然而并不能查到线程的pid,也就不能杀死一个线程。


线程的结束,要么是线程自己运行结束,要么就是主线程杀死子线程。


在线程中还有一个就是守护线程,守护线程,也就是在后台运行,主线程不会等待守护线程。使用守护进程的好处就是,主线程不用理会守护线程,如果主线程退出了,那么守护线程也就自动销毁了,守护线程的好处就是主线程不需要花时间来管理。


4、 python中的多线程模块介绍

在python中,多线程的模块一个是thread模块,还有一个是threading模块,推荐使用threading模块,因为threading属于高级模块,进行了大量的封装,东西总是越高级越好嘛。其实主要原因是,在thread模块中,你需要自己来进行管理子线程和主线程之间同步的问题,而在threading模块中,已经进行了相关的封装,从而不需要管同步的问题。


5、 多线程的例子

在使用python的多线程的时候,基本步骤如下:


直接调用函数的多线程如下:

#!/usr/bin/env python

from threading import Thread
import time

def loop(name,seconds):
    print 'start loop',name,' at:',time.ctime()
    time.sleep(1)
    print 'end loop',name,' at:',time.ctime()
    
if __name__ == '__main__':
    loops = [2,4]
    nloops = range(len(loops))
    threads = []
    print 'starting at :',time.ctime()
    for i in nloops:
        t = Thread(target=loop,args=(i,loops[i],))
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()

    print 'all DONE at :',time.ctime()

在这里,主要要做的操作在loop函数中,从而创建多个线程来执行loop函数,在创建线程对象Thread的时候,直接使用的是调用函数的方法,也就是创建线程的第一种方法,直接调用我们要进行操作的函数。

第二种方法使用的是可调用的类对象:

#!/usr/bin/env python

from threading import Thread
import time

def loop(name,seconds):
    print 'start loop',name,' at:',time.ctime()
    time.sleep(1)
    print 'end loop',name,' at:',time.ctime()
    
class ThreadFunc(object):
    def __init__(self,func,args,name=''):
        self.name = name
        self.func = func
        self.args = args

    def __call__(self):
        self.func(*self.args)

if __name__ == '__main__':
    loops = [2,4]
    nloops = range(len(loops))
    threads = []
    print 'starting at :',time.ctime()
    for i in nloops:
        t = Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__))
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()

    print 'all DONE at :',time.ctime()


在使用可调用类对象的时候,主要就是在类的定义中,需要定义个特殊的方法__call__,然后在创建Thread的时候,需要使用直接使用target为可调用对象的实例化。


第三种方法主要就是子类化,代码如下:

#!/usr/bin/env python

from threading import Thread
import time

def loop(name,seconds):
    print 'start loop',name,' at:',time.ctime()
    time.sleep(1)
    print 'end loop',name,' at:',time.ctime()
    
class ThreadFunc(Thread):
    def __init__(self,func,args,name=''):
        super(ThreadFunc,self).__init__()
        self.name = name
        self.func = func
        self.args = args

    def run(self):
        self.func(*self.args)

if __name__ == '__main__':
    loops = [2,4]
    nloops = range(len(loops))
    threads = []
    print 'starting at :',time.ctime()
    for i in nloops:
        t = ThreadFunc(loop,(i,loops[i]),loop.__name__)
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()

    print 'all DONE at :',time.ctime()

这种方法和第二种方法大同小异,主要就是在子类的时候集成Thread类,然后将可调用的方法修改为run方法即可,在Thread类对象中,如果需要继承,那么主要就是将run方法进行重写。

执行结果如下:

[root@python 522]# python thread_demo.py 
starting at : Sun May 22 03:44:49 2016
start loop 0  at: Sun May 22 03:44:49 2016
start loop 1  at: Sun May 22 03:44:49 2016
end loop 0  at: Sun May 22 03:44:50 2016
end loop 1  at: Sun May 22 03:44:50 2016
all DONE at : Sun May 22 03:44:50 2016

在一般推荐的方法中,是使用第三种方法,也就是子类化Thread类。

在这里用了三个循环,主要的目的是在进行创建的时候,不需要开启线程,从而在第二循环中,开启所有的线程。


6、 Thread基本方法

在threading的Thread类中,主要的方法是run方法,也就是在使用target初始化的时候关联的方法。

Thread实例的时候,提供target参数,就是需要执行的函数,另外一个args参数就是函数的参数,必须用元祖的形式提供,如果只有一个参数,必须在一个参数后加一个逗号,表示为元祖。

join表示主线程需不需要等待子线程,如果不需要,那么可以不调用join函数,在上面例子中,调用了join函数,从而主线程需要等待子线程,在使用了timeout参数之后,那么会表示主线程最多等多少秒,然后继续执行主线程,主线程结束,那么会将子线程结束掉

setDaemon是设置线程为守护线程,守护线程表示一个不重要线程,主线程结束,那么守护线程也就结束了,可以使用方法isDaemon来判断是否为守护线程

getname表示返回线程的名称,setname表示设置线程的名称,isalive表示线程是否还在运行

在设置守护线程的时候,必须在启动方法也就是start之前进行设置。


7、 线程之间的通信

具体的流程如下:


也就是生产者线程产生数据写入到共享数据中,然后消费者线程从共享数据中取出数据。

具体代码如下:

#!/usr/bin/env python

from threading import Thread
import time
from Queue import Queue

def writeQ(queue,i):
    while True:
        time.sleep(1)
        if queue.full():
            time.sleep(1)
        else:
            queue.put('xxx')
            print 'producting object for Q..',i

def readQ(queue,i):
    while True:
        time.sleep(1)
        if queue.empty():
            time.sleep(1)
            print 'empty'
        else:
            val = queue.get()
            print 'consumed object from Q..size now:',queue.qsize(),' consumer ' ,i

class Producter(Thread):
    def __init__(self,func,args,name=''):
        super(Producter,self).__init__()
        self.name = name
        self.args = args
        self.func = func

    def run(self):
        self.res = self.func(*self.args)
        #return self.res

class Consumer(Thread):
    def __init__(self,func,args,name=''):
        super(Consumer,self).__init__()
        self.name = name
        self.args = args
        self.func = func

    def run(self):
        self.res = self.func(*self.args)
        #return self.res

if __name__ =='__main__':
    q = Queue(100)
    for i in range(20):
        p = Producter(writeQ,(q,'production %s ' % i))
        p.start()
    for i in range(2):
        c = Consumer(readQ,(q,'consumer %s ' % i))
        c.start()
在其中,主要就是使用Queue进行线程间的通信,在以上的代码中,可以进行优化,例如提取公共类,派生子类生产者和消费者。


8、线程是不是可以无限创建

一下测试为测试线程是不是可以无限创建,代码如下:

[root@python 522]# cat thread_test.py 
#!/usr/bin/env python

from threading import Thread

def testThread():
    while True:
        pass
while True:
    t = Thread(target=testThread)
    t.start()

就是无限的创建线程。

vmstat基准线如下:


指标解释如下:

r 表示运行的队列,话说超过5,就很有压力了

in 表示中断的次数

cs 表示上下文切换

us 表示用户cpu时间

sy 表示系统的cpu时间


运行一段时间后,发现,这个procs的r数量增长很快,那么表示,有多少个的线程分配到了cpu

看出来,cpu很繁忙,中断的次数和上下文切换的数量很大,而且用户的cpu时间占比比较多。

在这个时候,登录系统的时候,会发现系统非常卡,可以看出来脑子。。。CPU根本不够用了。


杀掉进程之后恢复正常。。那么去掉cpu的限制,那么可以使用如下代码:

#!/usr/bin/env python

from threading import Thread
from time import sleep

i=0
def testThread():
    print i 

while True:
    i += 1
    t = Thread(target=testThread)
    t.start()

这次测试。。好像没有线程的限制。





阅读更多
换一批

没有更多推荐了,返回首页