学习python：day9

线程

1.什么是线程？

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

2.python GIL全局解释器锁（仅需了解）

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

首先需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

这篇文章透彻的剖析了GIL对python多线程的影响，强烈推荐看一下：http://www.dabeaz.com/python/UnderstandingGIL.pdf

3.python threading模块

threading模块建立在_thread 模块之上。thread模块以低级、原始的方式来处理和控制线程，而threading 模块通过对thread 进行二次封装，提供了更方便的 api来处理线程。

线程有两种调用方式，如下：

1）直接调用


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

import threading

import time

 

def sayhi(num): #定义每个线程要运行的函数

 

    print("running on number:%s" %num)

 

    time.sleep(3)

 

if __name__ == ‘__main__‘:

 

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例

    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

 

    t1.start() #启动线程

    t2.start() #启动另一个线程

 

    print(t1.getName()) #获取线程名

    print(t2.getName())

2）继承调用


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

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)

 

if __name__ == ‘__main__‘:

 

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start() 

Python通过两个标准库thread和threading提供对线程的支持。thread提供了低级别的、原始的线程以及一个简单的锁。

thread 模块提供的其他方法：

  • threading.currentThread(): 返回当前的线程变量。
  • threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  • threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

  • run(): 用以表示线程活动的方法。
  • start():启动线程活动。
  • join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
  • isAlive(): 返回线程是否活动的。
  • getName(): 返回线程名。
  • setName(): 设置线程名。

4.Join & Daemon

join 等待线程执行完后，其他线程再继续执行


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

import  threading,time

 

def run(n,sleep_time):

    print("test...",n)

    time.sleep(sleep_time)

    print("test...done", n)

if __name__ == ‘__main__‘:

 

    t1 = threading.Thread(target=run,args=("t1",2))

    t2 = threading.Thread(target=run,args=("t2",3))

 

    # 两个同时执行，然后等待t1执行完成后，主线程和子线程再开始执行

    t1.start()

    t2.start()

    t1.join()   # 等待t1

 

    print("main thread")

 

# 程序输出

# test... t1

# test... t2

# test...done t1

# main thread

# test...done t2

Daemon 守护进程

t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

import threading,time

 

def run(n):

    print(‘[%s]------running----\n‘ % n)

    time.sleep(2)

    print(‘--done--‘)

 

 

def main():

    for i in range(5):

        t = threading.Thread(target=run, args=[i, ])

        t.start()

        t.join(1)

        print(‘starting thread‘, t.getName())

 

 

m = threading.Thread(target=main, args=[])

m.setDaemon(True)  # 将main线程设置为Daemon线程,它做为程序主线程的守护线程,当主线程退出时,

                    # m线程也会退出,由m启动的其它子线程会同时退出,不管是否执行完任务

m.start()

m.join(timeout=2)

print("---main thread done----")

 

# 程序输出

# [0]------running----

# starting thread Thread-2

# [1]------running----

# --done--

# ---main thread done----

5.线程锁（互斥锁Mutex）

我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念。

例：假设列表A的所有元素就为0，当一个线程从前向后打印列表的所有元素，另外一个线程则从后向前修改列表的元素为1,那么输出的时候，列表的元素就会一部分为0，一部分为1,这就导致了数据的不一致。锁的出现解决了这个问题。

不加锁：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

import time

import threading

 

 

def addNum():

    global num  # 在每个线程中都获取这个全局变量

    print(‘--get num:‘, num)

    time.sleep(1)

    num -= 1  # 对此公共变量进行-1操作

 

 

num = 100  # 设定一个共享变量

thread_list = []

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

 

for t in thread_list:  # 等待所有线程执行完毕

    t.join()

 

print(‘final num:‘, num)

加锁：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

import time

import threading

 

 

def addNum():

    global num  # 在每个线程中都获取这个全局变量

    print(‘--get num:‘, num)

    time.sleep(1)

    lock.acquire()  # 修改数据前加锁

    num -= 1  # 对此公共变量进行-1操作

    lock.release()  # 修改后释放

 

 

num = 100  # 设定一个共享变量

thread_list = []

lock = threading.Lock()  # 生成全局锁

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

 

for t in thread_list:  # 等待所有线程执行完毕

    t.join()

 

print(‘final num:‘, num)

GIL VS LOCK

机智的同学可能会问到这个问题，就是既然你之前说过了，Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock? 注意啦，这里的lock是用户级的lock,跟那个GIL没关系 ，具体我们通过下图来看一下+配合我现场讲给大家，就明白了。

6.递归锁

说白了就是在一个大锁中还要再包含子锁


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

import threading, time

 

 

def run1():

    print("grab the first part data")

    lock.acquire()

    global num

    num += 1

    lock.release()

    return num

 

 

def run2():

    print("grab the second part data")

    lock.acquire()

    global num2

    num2 += 1

    lock.release()

    return num2

 

 

def run3():

    lock.acquire()

    res = run1()

    print(‘--------between run1 and run2-----‘)

    res2 = run2()

    lock.release()

    print(res, res2)

 

 

if __name__ == ‘__main__‘:

 

    num, num2 = 0, 0

    lock = threading.RLock()

    for i in range(10):

        t = threading.Thread(target=run3)

        t.start()

 

while threading.active_count() != 1:

    print(threading.active_count())

else:

    print(‘----all threads done---‘)

    print(num, num2)

threading.RLock和threading.Lock 的区别：

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。


1

2

3

4

5

6

import threading

lock = threading.Lock()    #Lock对象

lock.acquire()

lock.acquire()  #产生了死琐。

lock.release()

lock.release()

1

2

3

4

5

6

import threading

rLock = threading.RLock()  #RLock对象

rLock.acquire()

rLock.acquire()    #在同一线程内，程序不会堵塞。

rLock.release()

rLock.release()

7.信号量

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

import threading,time

 

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s\n" %n)

    semaphore.release()

 

if __name__ == ‘__main__‘:

 

    num= 0

    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

 

while threading.active_count() != 1:

    pass #print threading.active_count()

else:

    print(‘----all threads done---‘)

    print(num)

8.event

Event是线程间通信最间的机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

  • Event.wait([timeout]) ：堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
  • Event.set() ：将标识位设为Ture
  • Event.clear() ：将标识伴设为False。
  • Event.isSet() ：判断标识位是否为Ture。

当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

import threading,time

import random

def light():

    if not event.isSet():

        event.set() #wait就不阻塞 #绿灯状态

    count = 0

    while True:

        if count < 10:

            print(‘\033[42;1m--green light on---\033[0m‘)

        elif count <13:

            print(‘\033[43;1m--yellow light on---\033[0m‘)

        elif count <20:

            if event.isSet():

                event.clear()

            print(‘\033[41;1m--red light on---\033[0m‘)

        else:

            count = 0

            event.set() #打开绿灯

        time.sleep(1)

        count +=1

def car(n):

    while 1:

        time.sleep(random.randrange(10))

        if  event.isSet(): #绿灯

            print("car [%s] is running.." % n)

        else:

            print("car [%s] is waiting for the red light.." %n)

if __name__ == ‘__main__‘:

    event = threading.Event()

    Light = threading.Thread(target=light)

    Light.start()

    for i in range(3):

        t = threading.Thread(target=car,args=(i,))

        t.start()

9.队列

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

一些常用方法：

  • task_done()

意味着之前入队的一个任务已经完成。每一个get()调用得到一个任务，接下来的task_done()调用告诉队列该任务已经处理完毕。

如果当前一个join()正在阻塞，它将在队列中的所有任务都处理完时恢复执行（即每一个由put()调用入队的任务都有一个对应的task_done()调用）。

  • join()

阻塞调用线程，直到队列中的所有任务被处理掉。

只要有数据被加入队列，未完成的任务数就会增加。当线程调用task_done()（意味着有线程取得任务并完成任务），未完成的任务数就会减少。当未完成的任务数降到0，join()解除阻塞。

  • put(item[, block[, timeout]])

将item放入队列中。

  1. 如果可选的参数block为True且timeout为空对象（默认的情况，阻塞调用，无超时）。
  2. 如果timeout是个正整数，阻塞调用进程最多timeout秒，如果一直无空空间可用，抛出Full异常（带超时的阻塞调用）。
  3. 如果block为False，如果有空闲空间可用将数据放入队列，否则立即抛出Full异常

其非阻塞版本为put_nowait等同于put(item, False)

  • get([block[, timeout]])

从队列中移除并返回一个数据。block跟timeout参数同put方法

其非阻塞方法为｀get_nowait()｀相当与get(False)

  • empty()

如果队列为空，返回True,反之返回False

先入先出：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

#先入先出

import queue

q = queue.Queue()

for i in range(5):

    q.put(i)

while not q.empty():

    print(q.get())

#输出结果

#0

#1

#2

#3

#4

后入先出：


1

2

3

4

5

6

7

8

9

10

11

12

13

#后入先出

import queue

q = queue.LifoQueue()

for i in range(5):

    q.put(i)

while not q.empty():

    print(q.get())

#输出结果

#4

#3

#2

#1

#0

优先级队列：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

import queue

q = queue.PriorityQueue()

q.put((-1,"cc"))

q.put((3,"dd"))

q.put((10,"aa"))

q.put((6,"ww"))

print(q.get())

print(q.get())

print(q.get())

print(q.get())

#输出结果

#(-1, ‘cc‘)

#(3, ‘dd‘)

#(6, ‘ww‘)

#(10, ‘aa‘)
时间： 2024-11-06 03:43:23

学习python：day9的相关文章

学习Python随想

进入大三之后进入了一周基本都是专业课的状态,虽然相比之前几个学期课时量减少了,但实际上学要学习的任务却大大增加了,而类似于Python,spss这一类的课程是之前之前并没有听说过的,但在上过两周之后发现,Python是类似于c语言一类的课程,而之前的c语言和数据结构学得并不好,所以其实在内心深处是有一丝丝的惧怕的,希望在实践课上能多做一些类似于第一次的学打代码的联系,多找找感觉. 课堂进度十分之快,时而跟得上时而跟不上,而一旦跟不上就会跟多米诺骨牌似的,影响接下来的课堂学习.在智慧云教室最大的感

【个人计划】告别英雄联盟，开始学习Python

不知不觉中接触英雄联盟已经快两年了,记得是大四那年找完工作,一下比较清闲,宿舍刚好有lol的氛围,于是乎,四个新手在何大神的带领下,走上了lol的道路.不得不说,从那以后,花费在lol上的时间太多啦,据我估计,个人玩了将近2000了吧,别看局数这么多,其实就是个渣渣,技术太菜了,这也就是我告别英雄联盟的原因啦,根本没有玩这个游戏的天赋,技术上没有一点点提高,一直就是在浪费时间罢了. 就我个人而言,1.在补兵方面,时好时坏,而且有时候性子急,不太注重前期的补兵发育,往往导致输的结局:2.游戏中大部

学习python第一天

学习Python第一天 Python小白,做Linux运维5年,纯系统运维已经不能满足日常工作需要,所以学习Linux运维开发入门级语言python 前言: Python, 是一种面向对象.解释型计算机程序设计语言,由Guido van Rossum于1989年发明,第一个公开发行版发行于1991年. Python是纯粹的自由软件, 源代码和解释器CPython遵循 GPL(GNU General Public License)协议. Python语法简洁清晰,特色之一是强制用空白符(white

重新学习python系列(一)？ WTF？

重新学习python:两年前学了点python之后就一直没做做过啥项目, 基本上全忘光了,复习一下搞点事情 or |and & ord() ascii转16进制 chr()  16进制转ascii >>> u'ABC'.encode('utf-8') 'ABC' >>> u'中文'.encode('utf-8') '\xe4\xb8\xad\xe6\x96\x87' >>> 'abc'.decode('utf-8') u'abc' >&g

Python学习--Python基础语法

第一个Python程序 交互式编程 交互式编程不需要创建脚本文件,是通过 Python 解释器的交互模式进来编写代码. linux上你只需要在命令行中输入 Python 命令即可启动交互式编程,提示窗口如下: Window上在安装Python时已经已经安装了默认的交互式编程客户端,提示窗口如下: 在Python提示符中输入一下文本,然后按回车查看运行结果: print 'hello world'; 输出: hello world 脚本式编程 让我们来写一个简单的Python脚本,所有的Pytho

几条学习python的建议

熟悉python语言, 以及学会python的编码方式. 熟悉python库, 遇到开发任务的时候知道如何去找对应的模块. 知道如何查找和获取第三方的python库, 以应付开发任务. 学习步骤 安装开发环境 如果你在window下, 去下载pythonxy安装起来, 然后运行python, 进入python解释环境. 如果你在ubuntu下, 执行: sudo apt-get install python, 然后在命令行下运行python, 进入python解释环境. 学习方法 作为一名成熟的

鱼C《零基础入门学习Python》10-17节课时知识点总结

第10讲:列表:一个打了激素的数组 1. 列表都可以存放一些什么东西?  我们说 Python 的列表是一个打了激素的数组,如果把数组比喻成集装箱,那么 Python 的列表就是一个大仓库,Ta 可以存放我们已经学习过的任何数据类型. 2. 向列表增加元素有哪些方法?  三种方法想列表增加元素,分别是:append().extend() 和 insert().    3. append() 方法和 extend() 方法都是向列表的末尾增加元素,请问他们有什么区别?  append() 方法是将

学习python的小随笔

Python在课表中的名字是高级语言程序设计.上了两周的专业课,我想说我真的是想来学教育的,现在成了计算机了.我还想说,有没有一种可以用中文写程序的软件,有志向的大佬们赶紧弄个吧!       其实关于学习Python倒是不反感,无论是当初学习c++,还是现在学Python,都感觉这个东西挺有意思的.当你能把一个程序写出来并且运转成功之后,那种成就感是难以形容的.(哪怕是对着书敲上的)       希望老师教学中.把我们当做一个程序小白,很多老师以为学过了就精通了,可是事实不是那样.个人感觉Py

学习Python的第一课(简单的单元测试)

由于有C#开发基础,感觉学习Python应该不难,主要是一些语法了,再加上现在互联网这么发达. 感觉还是要有思路,否则学什么也只能是什么. 话不多说,简单发下这几天的学习成果吧: 第一次写博客,大家不要见笑啊 简单的语法就不多说了,随便搜搜就可以得到.() 单元测试来了: 要做两个测试: # 用于判断质数 import math def isPrime(n): print ("验证数字"+str(n)+"是否质数开始") print ("开平方:"

人在囧途——Java程序猿学习Python

引言 LZ之前其实一直对python都很好奇,只是苦于平时没有时间去了解它,因此趁着51假期这个机会,便迫不及待的开始了自己的探索.作为一个标准的Java程序猿,在了解python的过程当中,LZ遇到了很多囧事,接下来LZ就一一给大家说道说道.本文纯属看个乐子,非python教学. 囧事一:eclipse插件安装篇 由于LZ习惯了使用eclipse进行开发,因此对python的研究,还是希望可以在eclipse上进行试验.那么第一件事,自然是安装python的eclipse插件,于是百度.goo