线程、GIL、Lock锁、RLock锁、Semaphore锁、同步条件event

http://www.cnblogs.com/yuanchenqi/articles/6248025.html  博客地址

本节内容：

1：进程和线程的说明

2：线程的两种调用方式

3：threading.thread的实例方法

4：python的GIL

5：互斥锁Lock

6：递归锁Rlock

7：Semaphore锁

8：同步条件event

9：队列

1：进程和线程的说明

1
2
3
4
5
6
7
进程一般由程序、数据集、进程控制块三部分组成。
    我们编写的程序用来描述进程要完成哪些功能以及如何完成；
    数据集则是程序在执行过程中所需要使用的资源；
    进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。
 
 
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。

进程和线程的大白话

1
2
3
4
5
6
进程：本质上就是程序运行的实例
 
进程和进程之前的数据是不能共享的。
线程和线程之间可以共享。
 
比如说你开一个qq，qq就是qq程序执行的实例，是进程。而qq里面的功能就是各个线程。

2.线程的两种调用方式

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

提供了更方便的api来处理线程。

直接调用：

 View Code

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())

继承式调用：（ps没多大用，一般直接调用就好）

 View Code

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()

print("ending......")

3.threading.thread的实例方法

 join方法：

当线程对象采用join的时候，必须先执行完当前的子线程，主线程才可以工作；而子线程之间没有这个关系。

join()：在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

 View Code

import threading
import time

def music():
print("begin to listen %s"%time.ctime())
time.sleep(5)
print("end to listen %s" % time.ctime())

def game():
print("begin to game %s"%time.ctime())
time.sleep(3)
print("end to game %s" % time.ctime())


if __name__ == "__main__":
t1 = threading.Thread(target=music) ##开启了一个线程


t2 = threading.Thread(target=game) ##开启第二个线程
t2.start()
t1.start()
t1.join() ##t1不执行完，主线程不能走
t2.join() ##
print("end.......")

##输出 bengin game 和 listen同时打印出来，过了三秒end game再打印出来，等再过2秒打印出end listen 和 end....
# begin to game Sat Mar 17 22:20:37 2018
# begin to listen Sat Mar 17 22:20:37 2018
# end to game Sat Mar 17 22:20:40 2018
# end to listen Sat Mar 17 22:20:42 2018
# end.......

setDaemon 守护线程

 View Code

import threading
import time

def f1(i):
time.sleep(1)
print(i)

if __name__ == '__main__':
for i in range(5):
t = threading.Thread(target=f1, args=(i,))
t.setDaemon(True) ##守护主线程，。只要主线程结束，就陪着一起退出
t.start()

print('start') # 主线程不等待子线程

##输出
#start

1
2
3
4
5
setDaemon(True)：
         将线程声明为守护线程，必须在start() 方法调用之前设置， 如果不设置为守护线程程序会被无限挂起。这个方法基本和join是相反的。
         当我们 在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就分兵两路，分别运行，那么当主线程完成
         想退出时，会检验子线程是否完成。如 果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是 只要主线程
         完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以 用setDaemon方法啦。

其它方法

除此之外，自己还可以为线程自定义名字，通过 t = threading.Thread(target=f1, args=(i,), name='mythread{}'.format(i)) 中的name参数，除此之外，Thread还有一下一些方法

1
2
3
4
5
6
7
8
9
10
11
12
13
# run():  线程被cpu调度后自动执行线程对象的run方法
t.start()   :启动线程活动。
t.getName() : 获取线程的名称
t.setName() ： 设置线程的名称
t.name : 获取或设置线程的名称
t.is_alive() ： 判断线程是否为激活状态
t.isAlive() ：判断线程是否为激活状态
t.isDaemon() ： 判断是否为守护线程
 
threading模块提供的一些方法：
# threading.currentThread(): 返回当前的线程变量。
# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
# threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

4.python的GIL

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

上面的核心意思就是，无论你启多少个线程，你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许一个线程运行

GIL是存在于pythonC解释器中，你要想在python中使用多线程并行 那就别想了。java中是不存在这个锁的，但是用户需要繁琐的加锁解锁，保障线程的安全。

任务的区分：

1
2
对于IO密集型的任务，python的多线程是有意义的
对于计算密集型的任务；python的多线程不推荐，可以采用多进程+协程

并发&并行

1
2
3
4
并发：是指系统具有处理多个任务（动作）的能力 ；通俗的说就是cpu能够进行切换任务，就说具有了并发。
并行：是值系统具有同时处理多个任务（动作）的能力
 
并行是并发的一个子集

同步 & 异步

1
2
3
现象：如上个博文所说的socket，当你等待用户或服务端的数据recv 时，就一直阻塞在那里。这叫同步
同步：当进程执行到一个IO(等待外部数据的时候)，等 ---就是同步
异步：当进程执行到一个IO(等待外部数据的时候)，不等 ---就是异步

5.同步锁（也叫互斥锁）

复制代码
###开100个线程进行 累加或累减 
import threading
import time
def sub():
    global num
    temp = num
    time.sleep(0.0001)
    num = temp -1
    # num -= 1

num = 100
l = []
for i in range(100):
    t = threading.Thread(target=sub)
    t.start()
    l.append(t)

for i in l :
    i.join()

print(num)

# 输出：  我想要的是0  怎么给我输出了78了？
# 78
复制代码

分析：加的time.sleep()的区别就是cpu遇见了io阻塞，马上就进行切换。

大家都处理一个数据，而这个数据在进行切换的时候，数据还没执行完就进行切换，导致了同一时刻，不同的线程拿到了同一个数据。

解决办法：加同步锁

 View Code

import threading
import time
def sub():
global num
lock.acquire() ##将下面的代码锁起来，在我锁的过程谁都不能对下面的数据进行操作
temp = num
time.sleep(1) ##1秒意味着 100秒才可以出结果
num = temp -1
lock.release() ##释放锁
# num -= 1

num = 100
l = []
lock = threading.Lock() ###创建了一把锁
for i in range(100):
t = threading.Thread(target=sub)
t.start()
l.append(t)

for i in l :
i.join()

print(num)

# 输出：
# 0

1
2
3
4
5
6
7
8
9
10
11
12
13
def sub():
    global num
    print('ok')
    time.sleep(1)
    print('ok2')
    lock.acquire()  ##将下面的代码锁起来，在我锁的过程谁都不能对下面的数据进行操作
    temp = num
    time.sleep(0.01) ##1秒意味着 100秒才可以出结果
    num = temp -1
    lock.release()  ##释放锁
 
 
##我串行的部分就是 lock的三行部分 其他的还是 并行的，

6.死锁锁、递归锁

同步锁的缺点：

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁，因为系统判断这部分资源都正在使用，所有这两个线程在无外力作用下将一直等待下去。下面是一个死锁的例子：

死锁实例：

 View Code

import threading
import time

class MyThread(threading.Thread):
def actionA(self):
A.acquire()
print(self.name,"GotA",time.ctime()) ###self 是一个线程对象，打印出线程名字
time.sleep(2)

B.acquire()
print(self.name, "GotB", time.ctime())
time.sleep(2)
B.release() ##释放B锁
A.release() ##释放A锁


def actionB(self):
B.acquire()
print(self.name, "GotB", time.ctime()) ###self 是一个线程对象，打印出线程名字
time.sleep(1)

A.acquire()
print(self.name, "GotA", time.ctime())
A.release() ##释放A锁
B.release() ##释放B锁

def run(self):
self.actionA()
self.actionB()

if __name__ == '__main__':

##创建两把锁
A = threading.Lock()
B = threading.Lock()
L = []
for i in range(5):
t = MyThread()
t.start()
L.append(t)

for i in L:
i.join()

print('ending.........')


##5个线程一起走都要获取到lock a ，线程1拿到了a 其他四个都要等待，线程1 释放 a锁才能进来，
#线程1

# 输出：
# Thread-1 GotA Sun Mar 18 12:07:12 2018
# Thread-1 GotB Sun Mar 18 12:07:14 2018
# Thread-1 GotB Sun Mar 18 12:07:16 2018
# Thread-2 GotA Sun Mar 18 12:07:16 2018

解决办法 递归锁（Rlock）：

由于线程是共享同一份内存的，所以如果操作同一份数据，很容易造成冲突，这时候就可以为线程加上一个锁了，这里我们使用Rlock，而不使用Lock，因为Lock如果多次获取锁的时候会出错，而RLock允许在同一线程中被多次acquire，但是需要用n次的release才能真正释放所占用的琐，一个线程获取了锁在释放之前，其他线程只有等待。

 View Code

import threading
import time

class MyThread(threading.Thread):
def actionA(self):
rlock.acquire()
print(self.name,"GotA",time.ctime()) ###self 是一个线程对象，打印出线程名字
time.sleep(2)

rlock.acquire()
print(self.name, "GotB", time.ctime())
time.sleep(2)
rlock.release() ##释放B锁
rlock.release() ##释放A锁


def actionB(self):
rlock.acquire()
print(self.name, "GotB", time.ctime()) ###self 是一个线程对象，打印出线程名字
time.sleep(1)

rlock.acquire()
print(self.name, "GotA", time.ctime())
rlock.release() ##释放A锁
rlock.release() ##释放B锁

def run(self):
self.actionA()
self.actionB()

if __name__ == '__main__':

##创建两把锁
# A = threading.Lock()
# B = threading.Lock()
L = []
##创建递归锁
rlock = threading.RLock()
for i in range(5):
t = MyThread()
t.start()
L.append(t)

for i in L:
i.join()

print('ending.........')


##5个线程一起走都要获取到lock a ，线程1拿到了a 其他四个都要等待，线程1 释放 a锁才能进来，
#线程1

# 输出：
# Thread-1 GotA Sun Mar 18 12:17:52 2018
# Thread-1 GotB Sun Mar 18 12:17:54 2018
# Thread-1 GotB Sun Mar 18 12:17:56 2018
# Thread-1 GotA Sun Mar 18 12:17:57 2018
# Thread-3 GotA Sun Mar 18 12:17:57 2018
# Thread-3 GotB Sun Mar 18 12:17:59 2018
# Thread-3 GotB Sun Mar 18 12:18:01 2018
# Thread-3 GotA Sun Mar 18 12:18:02 2018
# Thread-5 GotA Sun Mar 18 12:18:02 2018
# Thread-5 GotB Sun Mar 18 12:18:04 2018
# Thread-2 GotA Sun Mar 18 12:18:06 2018
# Thread-2 GotB Sun Mar 18 12:18:08 2018
# Thread-2 GotB Sun Mar 18 12:18:10 2018
# Thread-2 GotA Sun Mar 18 12:18:11 2018
# Thread-5 GotB Sun Mar 18 12:18:11 2018
# Thread-5 GotA Sun Mar 18 12:18:12 2018
# Thread-4 GotA Sun Mar 18 12:18:12 2018
# Thread-4 GotB Sun Mar 18 12:18:14 2018
# Thread-4 GotB Sun Mar 18 12:18:16 2018
# Thread-4 GotA Sun Mar 18 12:18:17 2018
# ending.........

递归锁的，内部就是维护 了一个计算器默认是0，当有人用rlock 就+1，直到rlock = 0 才能继续，让线程竞争锁，谁抢到谁执行。

7：Semaphore锁

Semaphore锁也是锁的一种，类似于停车场 ，停车场一次可以停3辆车，当第三辆车来了之后，只能等待前面三辆车离开大于等于1辆 才能进入。

实例：

 View Code

import threading
import time


class MyThread(threading.Thread):
def run(self):
if more.acquire(): ##加锁 当停车场小于三的时候，车进入
time.sleep(3)
print(self.name)
more.release() ## 解锁，车离开 允许后面的车进来

more = threading.Semaphore(3) ##默认停车场三辆

l = []
for i in range(23):
t = MyThread()
t.start()
l.append(t)

for i in l:
i.join()

print('end........')


# 输出： 没三秒输出三个线程
# Thread-2
# Thread-1
# Thread-3

# Thread-4
# Thread-5
# Thread-6

8：同步条件event

在之前不管是加锁还是其他的，线程都是处于竞争的，谁抢到cpu就执行谁。而达不到一个相互协调工作的情况。

event的原理很简单：就是线程之间共同围绕着一个标志位，当线程A没有set标志位的时候，线程B阻塞住。当线程A set标志位的时候，让B线程执行。

达到一个同步的效果：

就三个方法记住：

# a client thread can wait for the flag to be set
event.wait()

# a server thread can set or reset it
event.set()
event.clear()

9.队列Queue

队列是一种数据结构，不懂什么是数据结构？

数据结构就是帮你存储数据的一种格式，比如说列表 是按一个个索引值去存储数据，而字典是通过哈希给你存储数据。

为什么要有队列？

之所以会出现队列是因为遇见了多线程，它保证了数据的安全。

创建队列对象

1
2
3
4
import  queue
 
q = queue.Queue()
q = queue.Queue(5) ##就表示创建了一个5个格子的队列

创建一个队列对象就类似创建了这样的一个格子，接下来我们就要往里面添值。

 添值

1
2
3
q.put(12)
q.put('hi')
q.put([1,3,4])

获取值

1
2
3
while 1 :
    data = q.get()
    print(data)

输出：

1
2
3
12
hi
[1, 3, 4]

完整代码

 View Code

import queue

q = queue.Queue()

q.put(12)
q.put('hi')
q.put([1,3,4])

while 1 :
data = q.get()
print(data)

我们说创建了一个格子，那么开始是怎么放置值的？

1
2
3
先进先出队列  queue.Queue()
后进先出队列  queue.LifoQueue()
按优先级队列  queue.PriorityQueue()
 后进先出

import queue

# q = queue.Queue()
q = queue.LifoQueue()
# q = queue.PriorityQueue()

q.put(12)
q.put('hi')
q.put([1,3,4])

while 1 :
data = q.get()
print(data)

# 输出：
# [1, 3, 4]
# hi
# 12

后进先出

数据越小优先级越高

 优先级队列

import queue

q = queue.PriorityQueue()

q.put([2,'hi'])
q.put([4,34])
q.put([6,[1,3,4]])

while 1 :
data = q.get()
# print(data)
print(data[1])

# 输出： 默认输出的是一个列表
# [2, 'hi']
# [4, 34]
# [6, [1, 3, 4]]

# hi
# 34
# [1, 3, 4]

优先级队列

其他的一些方法

复制代码
q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)  ##不等待程序往队列放值，直接报错
非阻塞 q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)  ##当队列满了，阻塞住程序，直到队列get出去，此方法表示不等待，直接报错
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作
复制代码
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xyhh/p/10860358.html