进程与线程

 ----------------------------------------START-----------------------------------------

1.进程:

　　　　进程就是一个程序在一个数据集上的一次动态执行过程.进程一般由程序,数据集,进程控制块组成.程序用来描述进程要完成那些功能以及如何完成;数据集则是程序在执行过程中所欲要使用的资源,进程控制块用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感知进程存在的唯一标志.

2.线程:

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

3.进程和线程的关系:

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

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

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

4.并行和并发:

　　　并行处理是计算机系统中能同时执行两个或者更多个处理的一种计算方法.

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

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

5.线程对象的创建:

　　Thread类直接创建:

import threading,time

def tingge():
    print('听歌!')
    time.sleep(4)
    print('不听了!')
def xieboke():
    print('写博客')
    time.sleep(3)
    print('不写了!')
    print(time.time() - s)
s=time.time()
tt1=threading.Thread(target=tingge)
tt2=threading.Thread(target=xieboke)
tt1.start()
tt2.start()
print('-----------------END-----------------')

　　Thread类继承式创建:

import time,threading
class MyThreading(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num=num
    def run(self):
        print('在跑的是:%s'%self.num)
        time.sleep(5)
        print(time.time()-s)

s=time.time()
t1=MyThreading(1)
t2=MyThreading(2)
t1.start()
t2.start()
print('--------------END------------')

　　join()和setDaemon()

　　#join():在子线程完成运行之前,这个子线程的父线程将一直被阻塞.

import threading ,time
#setDaemon(True):
'''
         将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。

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

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

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

def music(name):
    print('运行%s'%name)
    time.sleep(2)
    print('%s结束!'%name)
def blog(log):
    print('运行%s'%log)
    time.sleep(3)
    print('%s结束!'%log)
lists=[]
t1=threading.Thread(target=music,args=('杀猪刀',))
t2=threading.Thread(target=blog,args=('python',))
lists.append(t1)
lists.append(t2)

if __name__=='__main__':
    # t2.setDaemon(True)
    for i in lists:
        # i.setDaemon(True)
        i.start()
        # i.join()
    # t1.join()
    # t2.join()
    print('--------------END--------------')

6.GIL(全局解释器锁)

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

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

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

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

　　无论你有多少个线程,多少个CPU,Python在执行一个进程的时候会淡定的在同一时刻只允许一个线程运行.

　　Python是无法利用多核CPU实现多线程的

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

-----------------------------------------2017-05-08----------------------------------------

--------------------------------------------END----------------------------------------------