进程：将程序装载到内存并为它分配内存资源才能执行，这种执行程序称为进程，进程是资源的集合。
程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。
优点:允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了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() 的前面
主线程结束守护线程也结束。