python 进程和线程

进程：将程序装载到内存并为它分配内存资源才能执行，这种执行程序称为进程，进程是资源的集合。

程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。

优点:允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了CPU的利用率

缺点：进程只能在一个时间干一件事，进程在执行的过程中如果阻塞，整个进程就会挂起。

线程：包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

操作CPU，必须先创建线程。

进程与线程的区别：

线程共享内存空间，进程的内存是独立的。

同一进程中的线程可以相互通信，进程间的通讯必须有中间代理。

新线程很容易创建；新进程需要重复父进程。
线程可以对同一进程的线程进行控制和操作；进程只能对子进程行使控制。对主要内容的更改。

比如：有时间间隔的效果：

#conding:utf-8
import threading,time

def run(m):
    print'take',m
    time.sleep(2)
    
run('t1')  #两结果中间有间隔时间
run('t2')
    

多线程并发效果：

import threading,time

def run(m):
    print'take',m
    time.sleep(2)
    
t1=threading.Thread(target=run,args=('t1',))
t2=threading.Thread(target=run,args=('t2',))

t1.start()   #结果同时出现
t2.start()

继承式线程调用：

#conding:utf-8
import threading,time
class mythread(threading.Thread):
    def __init__(self,m):
        super(mythread,self).__init__()
        self.m=m
        
    def run(self):
        print'take',self.m
        time.sleep(2)
    
t1=mythread('t1')
t1.start()
t2=mythread('t2')  #使用继承式线程调用，无时间间隔
t2.start()

 time.sleep()对线程的影响：

#coding:utf-8
import threading,time
 
def run(m):
    print'take',m
    time.sleep(2) #方法中的时间间隔在显示结果时间上不显现，因为t1.start()是并发执行的。
    
start_time=time.time()
for i in range(50):
    t1=threading.Thread(target=run,args=('t-%s'%i,))    
    t1.start()   #循环中的对象并发执行调用run函数。把time.sleep(2)放到t1.start()的上面时间间隔就会显现。

print 'cost:',time.time()-start_time

start()函数一旦触动，for中的i不同值直接调用run()函数，显示结果前后顺序的时间花在i in rang(50）中。

主线程与子线程;

#coding:utf-8
import threading,time
 
def run(m):  #子线程
    print'take',m
    time.sleep(2) #方法中的时间间隔在显示结果时间上不显现，因为t1.start()是并发执行的。
    print'run结束',m
start_time=time.time()
for i in range(10):  #主线程
    t1=threading.Thread(target=run,args=('t-%s'%i,))    
    t1.start()   #循环中的对象并发执行调用run函数。把time.sleep(2)放到t1.start()的上面时间间隔就会显现。

print 'cost:',time.time()-start_time

结果：

take t-0
take t-1
take t-2
take t-3
take t-4
take t-5
take t-6
take t-7
take t-8
takecost: t-90.00299978256226

run结束 t-0
run结束 t-1
run结束 t-2
run结束 t-4
run结束 t-3
run结束 t-6
run结束 t-5
run结束 t-7
run结束 t-8
run结束 t-9

可以看出主线程和子线程是并发执行的主线程，之所以呈现这个顺序结果，是主程序中的for循环从1到10花费的时间刚好使每一个调用run()函数并发线程执行print'take',m

执行完显示出来，当把10赋给i后再执行print 'cost:',time.time()-start_time，这时候的并发执行的不同i值的子程序停2秒钟时，再分别执行：print'run结束',m  所以形成上面的结果。

计算所有线程结束所用的时间：

这里用到了join()函数，等待线程执行结束。

#coding:utf-8
import threading,time
from PIL.JpegImagePlugin import APP
 
def run(m):  #子线程
    print'take',m
    time.sleep(2) #方法中的时间间隔在显示结果时间上不显现，因为t1.start()是并发执行的。
    print'run结束',m
app=[]
start_time=time.time()
for i in range(10):  #主线程
    t1=threading.Thread(target=run,args=('t-%s'%i,))    
    t1.start()   #循环中的对象并发执行调用run函数。把time.sleep(2)放到t1.start()的上面时间间隔就会显现。
    app.append(t1)
for t in app:
    t.join()  #等待线程结束   

print 'cost:',time.time()-start_time

结果：

take t-0
take t-1
take t-2
take t-3
take t-4
take t-5
take t-6
take t-7
take t-8
take t-9
run结束 t-0
run结束 t-2
run结束 t-3
run结束 t-1
run结束 t-4
run结束 t-5
run结束 t-7
run结束 t-6
run结束 t-9
run结束 t-8
cost: 2.00300002098

判断线程为主、子线程:print  threading.current_thread()      <_MainThread(MainThread, started 17248)> 主线程

判断当前的进程数：threading.active_count()

setDaemon(True)   把当前线程设置为守护线程 ，必须添加到start() 的前面

主线程结束守护线程也结束。