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

python网络编程--线程(锁,GIL锁,守护线程)

时间:2019-01-11 23:21:31      阅读:242      评论:0      收藏:0      [点我收藏+]

标签:block   解释型   strong   cpu占用率   过程   两种   线程调度   进程id   应用程序   

1.线程

  1.进程与线程

进程有很多优点,它提供了多道编程,让我们感觉我们每个人都拥有自己的CPU和其他资源,可以提高计算机的利用率。很多人就不理解了,既然进程这么优秀,为什么还要线程呢?其实,仔细观察就会发现进程还是有很多缺陷的,主要体现在两点上:

  进程只能在一个时间干一件事,如果想同时干两件事或多件事,进程就无能为力了。

  进程在执行的过程中如果阻塞,例如等待输入,整个进程就会挂起,即使进程中有些工作不依赖于输入的数据,也将无法执行。

  如果这两个缺点理解比较困难的话,举个现实的例子也许你就清楚了:如果把我们上课的过程看成一个进程的话,那么我们要做的是耳朵听老师讲课,手上还要记笔记,脑子还要思考问题,这样才能高效的完成听课的任务。而如果只提供进程这个机制的话,上面这三件事将不能同时执行,同一时间只能做一件事,听的时候就不能记笔记,也不能用脑子思考,这是其一;如果老师在黑板上写演算过程,我们开始记笔记,而老师突然有一步推不下去了,阻塞住了,他在那边思考着,而我们呢,也不能干其他事,即使你想趁此时思考一下刚才没听懂的一个问题都不行,这是其二。

 

  现在你应该明白了进程的缺陷了,而解决的办法很简单,我们完全可以让听、写、思三个独立的过程,并行起来,这样很明显可以提高听课的效率。而实际的操作系统中,也同样引入了这种类似的机制——线程。

  2.线程的出现

cpu执行单位(实体)
60年代,在OS中能拥有资源和独立运行的基本单位是进程,然而随着计算机技术的发展,进程出现了很多弊端,一是由于进程是资源拥有者,创建、撤消与切换存在较大的时空开销,因此需要引入轻型进程;二是由于对称多处理机(SMP)出现,可以满足多个运行单位,而多个进程并行开销过大。
    因此在80年代,出现了能独立运行的基本单位——线程(Threads)。
    注意:进程是资源分配的最小单位,线程是CPU调度的最小单位.
    每一个进程中至少有一个线程。 
    
    在传统操作系统中,每个进程有一个地址空间,而且默认就有一个控制线程

    线程顾名思义,就是一条流水线工作的过程,一条流水线必须属于一个车间,一个车间的工作过程是一个进程

    车间负责把资源整合到一起,是一个资源单位,而一个车间内至少有一个流水线

    流水线的工作需要电源,电源就相当于cpu

    所以,进程只是用来把资源集中到一起(进程只是一个资源单位,或者说资源集合),而线程才是cpu上的执行单位。

    多线程(即多个控制线程)的概念是,在一个进程中存在多个控制线程,多个控制线程共享该进程的地址空间,相当于一个车间内有多条流水线,都共用一个车间的资源。

    例如,北京地铁与上海地铁是不同的进程,而北京地铁里的13号线是一个线程,北京地铁所有的线路共享北京地铁所有的资源,比如所有的乘客可以被所有线路拉。

  3.线程的特点
    先简单了解一下线程有哪些特点,里面的堆栈啊主存区啊什么的后面会讲,大家先大概了解一下就好啦。

  在多线程的操作系统中,通常是在一个进程中包括多个线程,每个线程都是作为利用CPU的基本单位,是花费最小开销的实体。线程具有以下属性。

1)轻型实体

      线程中的实体基本上不拥有系统资源,只是有一些必不可少的、能保证独立运行的资源。

      线程的实体包括程序、数据和TCB。线程是动态概念,它的动态特性由线程控制块TCB(Thread Control Block)描述。

2)独立调度和分派的基本单位。

    在多线程OS中,线程是能独立运行的基本单位,因而也是独立调度和分派的基本单位。由于线程很“轻”,故线程的切换非常迅速且开销小(在同一进程中的)。

3)共享进程资源。

    线程在同一进程中的各个线程,都可以共享该进程所拥有的资源,这首先表现在:所有线程都具有相同的进程id,这意味着,线程可以访问该进程的每一个内存资源;此外,还可以访问进程所拥有的已打开文件、定时器、信号量机构等。由于同一个进程内的线程共享内存和文件,所以线程之间互相通信不必调用内核。

4)可并发执行。

    在一个进程中的多个线程之间,可以并发执行,甚至允许在一个进程中所有线程都能并发执行;同样,不同进程中的线程也能并发执行,充分利用和发挥了处理机与外围设备并行工作的能力。
  4.线程的两种创建方式

    1)使用函数
from threading import Thread
from multiprocessing import Process
def f1(n):
    print(‘%s号线程任务‘%n)
def f2(n):
    print(‘%s号线程任务‘%n)
if __name__ == ‘__main__‘:
    t1 = Thread(target=f1,args=(1,))
    t2 = Thread(target=f2,args=(2,))
    t1.start()
    t2.start()
    print(‘主线程‘)

    2)使用面向对象的方式(类)

from threading import Thread

class MyThread(Thread):

    def __init__(self,name):
        # super(MyThread, self).__init__()
        super().__init__()
        self.name = name
    def run(self):
        print(‘hello girl :‘ + self.name)
if __name__ == ‘__main__‘:
    t = MyThread(‘alex‘)
    t.start()
    print(‘主线程结束‘)

  

    5.线程的方法

 

      进程是最小的内存分配单位

      线程是操作系统调度的最小党委

      线程被CPU执行了

      进程内至少含有一个线程

      进程中可以开启多个线程 

      开启一个线程所需要的时间要远小于开启一个进程

      多个线程内部有自己的数据栈,数据不共享

      全局变量在多个线程之间是共享的

    1.查看线程的进程id

from threading import Thread
from multiprocessing import Process
import os

def work():
    print(‘hello‘,os.getpid())

if __name__ == ‘__main__‘:
    #part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print(‘主线程/主进程pid‘,os.getpid())

    #part2:开多个进程,每个进程都有不同的pid
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print(‘主线程/主进程pid‘,os.getpid())

  

    2.验证线程是数据共享的

from  threading import Thread
from multiprocessing import Process
import os
def work():
    global n  #修改全局变量的值
    n=0

if __name__ == ‘__main__‘:
    # n=100
    # p=Process(target=work)
    # p.start()
    # p.join()
    # print(‘主‘,n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100


    n=1
    t=Thread(target=work)
    t.start()
    t.join()   #必须加join,因为主线程和子线程不一定谁快,一般都是主线程快一些,所有我们要等子线程执行完毕才能看出效果
    print(‘主‘,n) #查看结果为0,因为同一进程内的线程之间共享进程内的数据
# 通过一个global就实现了全局变量的使用,不需要进程的IPC通信方法

  

    3.多进程与多线程的效率对比

from threading import Thread
from multiprocessing import Process
import os
import time
def work():
    print(‘hello‘)

if __name__ == ‘__main__‘:
    s1 = time.time()
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()
    t.join()
    t1 = time.time() - s1
    print(‘进程的执行时间:‘,t1)
    print(‘主线程/主进程‘)
    ‘‘‘
    打印结果:
    hello
    进程的执行时间: 0.0
    主线程/主进程
    ‘‘‘

    s2 = time.time()
    #在主进程下开启子进程
    t=Process(target=work)
    t.start()
    t.join()
    t2 = time.time() - s2
    print(‘线程的执行时间:‘, t2)
    print(‘主线程/主进程‘)
    ‘‘‘
    打印结果:
    hello
    线程的执行时间: 0.5216977596282959
    主线程/主进程
    ‘‘‘

  线程的事件:

import time
from threading import Thread,Semaphore,Event

def func():
    sm.acquire()
    print(‘get sm‘)
    time.sleep(1)
    sm.release()
if __name__ == ‘__main__‘:

    sm=Semaphore(5)
    for i in range(23):
        t=Thread(target=func)
        t.start()

e = Event() #初始状态False
print(e.is_set())
print(‘开始等待‘)
e.set() #将事件对象的状态改为True
e.clear() #将事件对象的状态改为false
e.wait()  #当e对象的状态为False的时候会在这个地方阻塞,改为true之后就直接往下执行
# print(e.is_set())
print(‘结束等待‘)

  

2.守护线程

无论是进程还是线程,都遵循:守护xx会等待主xx运行完毕后被销毁。需要强调的是:运行完毕并非终止运行

1.对主进程来说,运行完毕指的是主进程代码运行完毕

2.对主线程来说,运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕,主线程才算运行完毕


详细解释

主进程在其代码结束后就已经算运行完毕了(守护进程在此时就被回收),然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程),才会结束,

主线程在其他非守护线程运行完毕后才算运行完毕(守护线程在此时就被回收)。因为主线程的结束意味着进程的结束,进程整体的资源都将被回收,而进程必须保证非守护线程都运行完毕后才能结束,因为进程执行结束是要回收资源的,所有必须确保你里面的非守护子线程全部执行完毕。
import time
from threading import Thread
from multiprocessing import Process

#守护进程:主进程代码执行运行结束,守护进程随之结束

#守护线程:守护线程会等待所有非守护线程运行结束才结束

def f1():
    time.sleep(2)
    print(‘1号线程‘)
def f2():
    time.sleep(3)
    print(‘2号线程‘)

if __name__ == ‘__main__‘:
    t1 = Thread(target=f1,)
    t2 = Thread(target=f2,)
    # t1.daemon = True
    t2.daemon = True
    t1.start()
    t2.start()
    print(‘主线程结束‘)
    # t1 = Process(target=f1, )
    # t2 = Process(target=f2, )
    # t1.daemon = True
    # # t2.daemon = True
    # t1.start()
    # t2.start()
    #
    # print(‘主进程结束‘)

  示例2:

from threading import Thread
from multiprocessing import Process
import time
def func1():
    while True:
        print(666)
        time.sleep(0.5)
def func2():
    print(‘hello‘)
    time.sleep(3)

if __name__ == ‘__main__‘:
    # t = Thread(target=func1,)
    # t.daemon = True  #主线程结束,守护线程随之结束
    # # t.setDaemon(True) #两种方式,和上面设置守护线程是一样的
    # t.start()
    # t2 = Thread(target=func2,) #这个子线程要执行3秒,主线程的代码虽然执行完了,但是一直等着子线程的任务执行完毕,主线程才算完毕,因为通过结果你会发现我主线程虽然代码执行完毕了,    # 但是主线程的的守护线程t1还在执行,说明什么,说明我的主线程还没有完毕,只不过是代码执行完了,一直等着子线程t2执行完毕,我主线程的守护线程才停止,说明子线程执行完毕之后,我的主线程才执行完毕
    # t2.start()
    # print(‘主线程代码执行完啦!‘)
    p = Process(target=func1,)
    p.daemon = True
    p.start()

    p2 = Process(target=func2,)
    p2.start()
    time.sleep(1) #让主进程等1秒,为了能看到func1的打印效果
    print(‘主进程代码执行完啦!‘) #通过结果你会发现,如果主进程的代码运行完毕了,那么主进程就结束了,因为主进程的守护进程p随着主进程的代码结束而结束了,守护进程被回收了,这和线程是不一样的,主线程的代码完了并不代表主线程运行完毕了,需要等着所有其他的非守护的子线程执行完毕才算完毕

  

3.锁

1.GIL锁(Global Interpreter Lock)------Cpython解释器上的一把互斥锁

    首先,一些语言(java、c++、c)是支持同一个进程中的多个线程是可以应用多核CPU的,也就是我们会听到的现在4核8核这种多核CPU技术的牛逼之处。那么我们之前说过应用多进程的时候如果有共享数据是不是会出现数据不安全的问题啊,就是多个进程同时一个文件中去抢这个数据,大家都把这个数据改了,但是还没来得及去更新到原来的文件中,就被其他进程也计算了,导致数据不安全的问题啊,所以我们是不是通过加锁可以解决啊,多线程大家想一下是不是一样的,并发执行就是有这个问题。但是python最早期的时候对于多线程也加锁,但是python比较极端的(在当时电脑cpu确实只有1核)加了一个GIL全局解释锁,是解释器级别的,锁的是整个线程,而不是线程里面的某些数据操作,每次只能有一个线程使用cpu,也就说多线程用不了多核,但是他不是python语言的问题,是CPython解释器的特性,如果用Jpython解释器是没有这个问题的,Cpython是默认的,因为速度快,Jpython是java开发的,在Cpython里面就是没办法用多核,这是python的弊病,历史问题,虽然众多python团队的大神在致力于改变这个情况,但是暂没有解决。(这和解释型语言(python,php)和编译型语言有关系吗???待定!,编译型语言一般在编译的过程中就帮你分配好了,解释型要边解释边执行,所以为了防止出现数据不安全的情况加上了这个锁

    但是有了这个锁我们就不能并发了吗?当我们的程序是偏计算的,也就是cpu占用率很高的程序(cpu一直在计算),就不行了,但是如果你的程序是I/O型的(一般你的程序都是这个)(input、访问网址网络延迟、打开/关闭文件读写),在什么情况下用的到高并发呢(金融计算会用到,人工智能(阿尔法狗),但是一般的业务场景用不到,爬网页,多用户网站、聊天软件、处理文件),I/O型的操作很少占用CPU,那么多线程还是可以并发的,因为cpu只是快速的调度线程,而线程里面并没有什么计算,就像一堆的网络请求,我cpu非常快速的一个一个的将你的多线程调度出去,你的线程就去执行I/O操作了,

技术分享图片

 

2.同步锁 

1.线程抢的是GIL锁,GIL锁相当于执行权限,拿到执行权限后才能拿到互斥锁Lock,其他线程也可以抢到GIL,但如果发现Lock仍然没有被释放则阻塞,即便是拿到执行权限GIL也要立刻交出来

2.join是等待所有,即整体串行,而锁只是锁住修改共享数据的部分,即部分串行,要想保证数据安全的根本原理在于让并发变成串行,join与互斥锁都可以实现,毫无疑问,互斥锁的部分串行效率要更高

   锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象,当你需要访问该资源时,调用acquire方法来获取锁对象(如果其它线程已经获得了该锁,则当前线程需等待其被释放),待资源访问完后,再调用release方法释放锁:

import threading

R=threading.Lock()

R.acquire() #
#R.acquire()如果这里还有一个acquire,你会发现,程序就阻塞在这里了,因为上面的锁已经被拿到了并且还没有释放的情况下,再去拿就阻塞住了
‘‘‘
对公共数据的操作
‘‘‘
R.release()

  

 3.GIL与同步锁

Python已经有一个GIL来保证同一时间只能有一个线程来执行了,为什么这里还需要lock? 

首先我们需要达成共识:锁的目的是为了保护共享的数据,同一时间只能有一个线程来修改共享的数据

然后,我们可以得出结论:保护不同的数据就应该加不同的锁。

最后,问题就很明朗了,GIL 与Lock是两把锁,保护的数据不一样,前者是解释器级别的(当然保护的就是解释器级别的数据,比如垃圾回收的数据),后者是保护用户自己开发的应用程序的数据,很明显GIL不负责这件事,只能用户自定义加锁处理,即Lock

过程分析:所有线程抢的是GIL锁,或者说所有线程抢的是执行权限

线程1抢到GIL锁,拿到执行权限,开始执行,然后加了一把Lock,还没有执行完毕,即线程1还未释放Lock,有可能线程2抢到GIL锁,开始执行,执行过程中发现Lock还没有被线程1释放,于是线程2进入阻塞,被夺走执行权限,有可能线程1拿到GIL,然后正常执行到释放Lock。。。这就导致了串行运行的效果

既然是串行,那我们执行

  
    t1.start()

    t1.join

    t2.start()

    t2.join()
    这也是串行执行啊,为何还要加Lock呢,需知join是等待t1所有的代码执行完,相当于锁住了t1的所有代码,而Lock只是锁住一部分操作共享数据的代码。

 解释:

因为Python解释器帮你自动定期进行内存回收,你可以理解为python解释器里有一个独立的线程,每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的,此时你自己的程序里的线程和 

py解释器自己的线程是并发运行的,假设你的线程删除了一个变量,py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻,可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了,

结果就有可能新赋值的数据被删除了,为了解决类似的问题,python解释器简单粗暴的加了锁,即当一个线程运行时,其它人都不能动,这样就解决了上述的问题, 这可以说是Python早期版本的遗留问题。

   4.死锁现象

    所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁

import time
from threading import Thread,Lock,RLock

def f1(locA,locB):
    locA.acquire()
    print(‘f1>>1号抢到了A锁‘)
    time.sleep(1)
    locB.acquire()
    print(‘f1>>1号抢到了B锁‘)
    locB.release()

    locA.release()
def f2(locA,locB):
    locB.acquire()

    print(‘f2>>2号抢到了B锁‘)

    locA.acquire()
    time.sleep(1)
    print(‘f2>>2号抢到了A锁‘)
    locA.release()

    locB.release()
if __name__ == ‘__main__‘:
    locA = Lock()
    locB = Lock()
    t1 = Thread(target=f1,args=(locA,locB))
    t2 = Thread(target=f2,args=(locA,locB))
    t1.start()
    t2.start()

更难一些的死锁现象

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print(‘\033[41m%s 拿到A锁>>>\033[0m‘ %self.name)
        mutexB.acquire()
        print(‘\033[42m%s 拿到B锁>>>\033[0m‘ %self.name)
        mutexB.release()
        mutexA.release()

    def func2(self):
        mutexB.acquire()  
        print(‘\033[43m%s 拿到B锁???\033[0m‘ %self.name)
        time.sleep(2)
        #分析:当线程1执行完func1,然后执行到这里的时候,拿到了B锁,线程2执行func1的时候拿到了A锁,那么线程2还要继续执行func1里面的代码,再去拿B锁的时候,发现B锁被人拿了,那么就一直等着别人把B锁释放,那么就一直等着,等到线程1的sleep时间用完之后,线程1继续执行func2,需要拿A锁了,但是A锁被线程2拿着呢,还没有释放,因为他在等着B锁被释放,那么这俩人就尴尬了,你拿着我的老A,我拿着你的B,这就尴尬了,俩人就停在了原地

        mutexA.acquire()
        print(‘\033[44m%s 拿到A锁???\033[0m‘ %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == ‘__main__‘:
    for i in range(10):
        t=MyThread()
        t.start()

‘‘‘
Thread-1 拿到A锁>>>
Thread-1 拿到B锁>>>
Thread-1 拿到B锁???
Thread-2 拿到A锁>>>
然后就卡住,死锁了
‘‘‘

  

 解决方式,使用递归锁

4.递归锁

    递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。

    这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的

acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:

import time
from threading import Thread, Lock, RLock
def f1(locA, locB):
    # print(‘xxxx‘)
    # time.sleep(0.1)
    locA.acquire()
    print(‘f1>>1号抢到了A锁‘)

    time.sleep(1)
    locB.acquire()
    print(‘f1>>1号抢到了B锁‘)
    locB.release()

    locA.release()
def f2(locA, locB):
    print(‘22222‘)
    time.sleep(0.1)
    locB.acquire()
    print(‘f2>>2号抢到了B锁‘)
    locA.acquire()
    time.sleep(1)
    print(‘f2>>2号抢到了A锁‘)
    locA.release()
    locB.release()
if __name__ == ‘__main__‘:
    # locA =locB = Lock()
    locA = Lock()
    locB = Lock()
    # locA = locB = RLock()  #递归锁,维护一个计数器,acquire一次就加1,release就减1
    t1 = Thread(target=f1, args=(locA, locB))
    t2 = Thread(target=f2, args=(locA, locB))
    t1.start()
    t2.start()

  

 

python网络编程--线程(锁,GIL锁,守护线程)

标签:block   解释型   strong   cpu占用率   过程   两种   线程调度   进程id   应用程序   

原文地址:https://www.cnblogs.com/robertx/p/10257645.html

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