码迷,mamicode.com
首页 > 编程语言 > 详细

python--进程/线程

时间:2017-05-08 21:04:08      阅读:220      评论:0      收藏:0      [点我收藏+]

标签:getname   线程变量   设置   .com   支持   生成   ret   list   ==   

进程/线程

1 进程

操作系统进程切换:

1 出现IO操作:

2 固定时间:

 

2 进程定义 (资源管理单位)---(容器)

进程就是一个程序在一个数据集上的一次动态执行过程,进程一般由程序、数据集、进程控制块三部分组成。

实现并发过程

进程是相互独立的。

 

3 线程(最小执行单位)

线程的出现是为了降低上下文切换的消耗,提供系统的并发性,并突破一个进程只能干一样的缺陷,使到进程内并发成为可能。

 

4 进程与线程的关系

进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配

和调度的基本单位,是操作系统结构的基础

线程则是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位

进程与线程的关系:

(1)一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程。

(2)资源分配给进程,同一进程的所有线程共享该进程的所有资源

(3)CPU分给线程,即真正在CPU上运行的是线程

 

5 并行和并发

技术分享

并行处理(Parallel Processing)

是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作与统一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间

并发处理(concurrency Processing)

指一个时间段中有几个程序处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序在处理机(CPU)上运行

并发的关键是你有处理多个任务的能力,不一定要同时。并行的关键是你有同时处理多个任务的能力,所以说,并行是并发的子集

技术分享

注意:

Python败笔多线程:由于GIL,导致同一时刻,同一进程只能有一个线程被运行。多进程可以并行,多线程不能并行。

 

6 同步与异步

同步:在计算机领域,同步就是指一个进程在执行某个请求的时候,若该请求需要一段时间才能返回信息,那么这个进程将会一直等待下去,直到收到返回信息才继续执行下去

异步:是指进程不需要一直等待下去,而是继续执行面的操作,不管其他进程的状态,当有消息返回时系统会通知进程进行处理

 

7 Threading模块

 Thread类执行创建:

import threading
import time

def listen():
    print("listen to the music")
    time.sleep(3)
    print("listne stop")

def write():
    print("writing blog")
    time.sleep(5)
    print("writing stop")

t1=threading.Thread(target=listen) #生成一条线程
t2=threading.Thread(target=write) #生成第二条线程
t1.start() #启动线程
t2.start()
print("ending") #主线程



执行效果:
listen to the music
writing blog
ending
listne stop
writing stop

技术分享

 

Thread类继承式创建:

import threading
import time
class Mythread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num=num
    def run(self):
        print("running on number:%s"%self.num)
        time.sleep(3)
t1=Mythread(56)
t2=Mythread(73)
t1.start()
t2.start()
print("ending")



执行结果:
running on number:56
running on number:73
ending

  

Thread类的实例方法:  

 Join()

t.join() : 线程对象t未执行完,会阻塞你的主线程。跟子线程没有关系

import threading
import time
from time import ctime,sleep

def Music(name):
    print("Begin listening to {name}".format(name=name,time=ctime()))
    sleep(3)
    print("end listenting{time}".format(time=ctime()))
def Blog(title):
    print("Begin recording the {title}".format(title=title,time=ctime ()))
    sleep(5)
    print("end recording the {time}".format(time=ctime()))
threads=[]
t1=threading.Thread(target=Music,args=("FILL ME",))
t2=threading.Thread(target=Blog,args=("python",))

threads.append(t1)
threads.append(t2)
if __name__ == ‘__main__‘:
    for t in threads:
        t.start()
        # t.join() # 最后出现主程序 等t1  t2执行完之后
    # t1.join()  #t1线程不结束 其他线程不能执行 先执行t1,t2 然后在执行t1结束之后再执行主线程
    t2.join() #t1 t2执行完之后再打印主程序

    print("all over %s" %ctime())

 

setDeamon(True)  

       将线程声明为守护线程,必须在start()方法调用之前设置,如果不设置为守护线程程序会被无限挂起。

       当我们在程序运行中,执行一个主线程,如果主线程有创建一个子线程 就兵分两路,分别运行,那么当主线程完成

       想退出时,会检验子线程是否完成,如果子线程未完成,则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程

       完成了,不管子线程是否完成,都要和主线程一起退出,这时就可以用setDeamon方法啦

import threading
import time
from time import ctime,sleep

def Music(name):
    print("Begin listening to {name}".format(name=name,time=ctime()))
    sleep(3)
    print("end listenting{time}".format(time=ctime()))
def Blog(title):
    print("Begin recording the {title}".format(title=title,time=ctime ()))
    sleep(5)
    print("end recording the {time}".format(time=ctime()))
threads=[]
t1=threading.Thread(target=Music,args=("FILL ME",))
t2=threading.Thread(target=Blog,args=("python",))

threads.append(t1)
threads.append(t2)
if __name__ == ‘__main__‘:
    # 守护线程跟着主线程走,t1 t2两个都设置为守护线程,主线程执行完 其他就都不执行
    # t1.setDaemon(True)  #把t1设置为守护线程,等待t2执行结束,但是t1也需要执行,正常执行
    t2.setDaemon(True) #把t2设置为守护线程,主线程结束,t2也就跟着结束,不执行
    for t in threads: #for遍历
        t.start()
  
    print("all over %s" %ctime())

其他方法:

 Thread实例对象的方法

 isAlive():返回线程是否活动的

 getName():返回线程名

 setName():设置线程名

 

threading模块提供的一些方法:

 threading.currentThread(): 返回当前的线程变量。

 threading.enumerate():返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。

 threading.activeCount():返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。

 

8 GIL(全局解释锁)

Python中的线程是操作系统的原生线程,python虚拟机使用一个全局解释器锁(Global Interpreter Lock)来互斥线程对python虚拟机的使用。为了支持多线程机制,一个基本的要求就是需要实现不同线程对共享资源访问的互斥,所有引入了GIL。

加在C python解释其上,为了支持多线程机制,一个基本的要求就是需要实现不同线程对共享资源访问的互斥,所以引入了GIL。

GIL:在一个线程拥有了解释器的访问权之后,其他的所有线程都必须等他它释放解释器的访问权,即使这些线程的下一条指令并不会互相影响。

在调用任何Python  C  API之前,要先获得GIL

GIL缺点:多处理器退化为单处理器;优先:避免大量的加解锁操作

GIL的影响

无论你启多个线程,你有多少个cpu,Python在执行一个进程的时候会谈定的在同一时刻只允许一个线程运行。

所有,python是无法利用多核CPU实现多线程的

这样,python对于计算机密型的任务开多线程的效率甚至不如串行(没有大量切换),但是,对于IO密集型的任务效率还是有显著提升的。

技术分享

 

import time

def cal(n):
    sum=0
    for i in range(n):
        sum+=i

s=time.time()

# import threading
# t1=threading.Thread(target=cal,args=(10000000,))
# t2=threading.Thread(target=cal,args=(10000000,))
#
# t1.start()
# t2.start()
# t1.join()
# t2.join()
# # time 10.940000057220459
# # time 1.1090002059936523

cal(10000000)
cal(10000000)

print("time",time.time()-s)
# time 10.986999750137329
# time 1.128000020980835

计算密集型:一直在使用CPU

IO:存在大量IO操作

总结:对于计算密集型任务:Python的多线程并没有用

        对于IO密集型任务:Python的多线程是有意义的

Python使用多核:开进程,弊端:开销大而且切换复杂

 

python--进程/线程

标签:getname   线程变量   设置   .com   支持   生成   ret   list   ==   

原文地址:http://www.cnblogs.com/niejinmei/p/6827074.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!