多线程同步有几种实现方法C语言,线程同步与并发

今天来学习线程同步与并发,我们先来看一下线程之间的几种通信方式:

1.线程之间的几种通信方式

Event:事件;

Critical Section:临界区;

Semaphone:信号量;

2.Event事件的使用

Event是事件处理的机制,全局定义了一个内置标志Flag,如果Flag值为 False,那么当程序执行 event.wait方法时就会阻塞,如果Flag值为True, 那么event.wait 方法时便不再阻塞;

我们先来看看下面的实例:

from threading import Thread, Event

import time

def teacher(event: Event):

print('I am teacher , waiting for your homework')

event.wait()

print("I am teacher, already obtaining student's homework ")

def student(event: Event):

finished_homework = []

while len(finished_homework) < 10:

time.sleep(1)

print('I am student, finished one homework')

finished_homework.append(1)

else:

print('student finish homework')

event.set()

if __name__ == '__main__':

event = Event()

Thread(target=student, args=(event,)).start()

Thread(target=teacher, args=(event,)).start()

这个实例首先从threading 模块中导入了Thread和Event两个类,然后定义了两个方法teacher和student,在if __name__ == '__main__'中执行了这两个方法。

按照正常一般的代码执行顺序,会先打印teacher方法中的第一个print,然后来到了event.wait(),wait()方法的语法为wait(self, timeout=None),timeout用于设置等待的时长,如果超过时长则不再等待,直接向下执行,如果timeout没有指定则一 直等待,等待的时候是阻塞的;

我们可以看到teacher方法中的event.wait()并没有设置timeout,所以会阻塞,开始执行student方法,student方法里面是一个while循环,需要打印10遍print中的内容,打印完毕后进入else,其中有一个event.set()方法,会将flag设置为True,wait等待的线程就可以向下执行;

所以刚刚teacher方法中等待的会继续执行,我们来看一下输出结果:

I am teacher , waiting for your homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

I am student, finished one homework

student finish homework

I am teacher, already obtaining student's homework

event实例对象的对象方法介绍:

wait(self, timeout=None):timeout为设置等待的时长,如果超过时长(返回值为False)则不再等待,直接向下执行,如果timeout没有指定则一 直等待,等待的时候是阻塞的没有返回值,;

set():如果执行event.set(),将会设置flag为True,那么wait等待的线程就可以向下执行;

clear():如果执行event.clear(),将会设置flag标记为Flase, 那么wait等待的线程将再次等待(阻塞);

is_set():判断event的flag是否为True,如果为True的话wait等待的线程将向下执行;

3.线程锁

Lock是Python中最底层的同步机制,直接由底层模块 thread 实现,每个lock对象只有两种状态,也就是上锁和未上锁;

我们可以通过下面两种方式创建一个Lock对象,注意新创建的 Lock 对象处于未上锁的状态:

thread.allocate_lock()

threading.Lock()

锁是解决临界区资源的问题,保证每一个线程访问临界资源的时候有全部的权利,一旦某个线程获得锁, 其它试图获取锁的线程将被阻塞;

locked()方法:用于判断当前是否上锁,如果上锁,返回True,否则返回False;

acquire(blocking=True,timeout=-1):表示加锁,默认True为加锁状态(阻塞),False为不阻塞,timeout为设置时长;

release()方法:用于释放锁,在完成任务的时候释放锁,让其他的线程获取到临界资源,注意此时必须处于上锁的状态,如果试图释放一个unlocked 的锁,将抛出异常 thread.error;

我们通过两个实例来看一下线程锁的作用:

实例1:

import time

from threading import Thread

homework_list = []

def student(number):

while len(homework_list) < number: # 满足条件则继续执行下面的代码

time.sleep(0.001) # 等待0.001秒

homework_list.append(1)

print(len(homework_list))

if __name__ == '__main__':

for i in range(10):

Thread(target=student, args=(10, )).start() # 同时开启10个线程

time.sleep(3) # 等待3秒

print('完成作业的总数为: {}'.format(len(homework_list)))

运行实例1,我们发现最终输出结果完成作业的总数为:19,但是根据代码逻辑来看,应该输出10才对,这是为什么呢?其实是因为在多线程情况下操作临界资源,出现了临界资源争抢的问题,那如何解决这个问题呢,我们来看实例2;

实例2:

import time

import threading

from threading import Thread, Lock

homework_list = []

lock = Lock() # 全局阻塞锁

def student(number):

while True:

lock.acquire() # 一定要在获取临界资源之前加锁

if len(homework_list) >= number: # 满足条件则跳出循环,不满足则继续

break

time.sleep(0.001) # 等待0.001秒

homework_list.append(1)

lock.release() # 完成任务的时候释放锁,让其他的线程获取到临界资源

print('current_thread={}, homework_list={}'.format(threading.current_thread().name, len(homework_list)))

if __name__ == '__main__':

for i in range(10):

Thread(target=student, name='student {}'.format(i), args=(10, )).start() # 同时开启10个线程

time.sleep(3) # 等待3秒

print('完成作业的总数为: {}'.format(len(homework_list)))

运行实例2发现最终输出完成作业的总数为: 10,是我们想要的结果,实例1和实例2 不同之处在于实例2在获取临界资源之前加了锁,也就是lock.acquire(),我们知道一旦某个线程获得锁, 其它试图获取锁的线程将被阻塞,所以这里不会再发生临界资源争抢的问题了;

4.锁在with语句中的使用

使用with语句加锁with lock,会默认自动释放锁,不需要再使用release()方法来释放锁了,这样可以避免程序中忘记释放锁,更加方便;

import time

import threading

from threading import Thread, Lock

homework_list = []

# 全局阻塞锁

lock = Lock()

def student(number):

while True:

with lock:

if len(homework_list) >= number:

break

time.sleep(0.001)

homework_list.append(1)

print('current_thread={}, homework_list={}'.format(threading.current_thread().name, len(homework_list)))

if __name__ == '__main__':

for i in range(10):

Thread(target=student, name='student {}'.format(i), args=(1000, )).start()

time.sleep(3)

print('完成作业的总数为: {}'.format(len(homework_list)))

所以其实这样写,和上面的实例2是一样的效果哟,并且省略了释放锁的步骤,因为with默认自动释放锁,这样就不怕忘记释放锁而导致代码报错了;

5.线程池

接下来学习一下线程池,也就是ThreadPoolExecutor,线程池在构造实例的时候,会传入max_workers参数来设置线程池中最多能同时运行的线程数目;

线程池实例对象有两个非常使用的方法,submit方法和map方法:

submit(self, fn, *args, **kwargs):提交线程需要执行的任务(函数名和参数)到线程池中,并返回该任务的句柄,用于提交单个任务;

map(self, fn, *iterables, timeout=None, chunksize=1):类似高阶函数map,可以提交任务,且传递一个可迭代对象,返回任务处理迭代对象的结果;

from concurrent.futures import ThreadPoolExecutor

import requests

def fetch_url(url):

result = requests.get(url=url, )

return result.text

# 创建10个线程队列的线程池

pool = ThreadPoolExecutor(10)

# 获取任务返回对象

a = pool.submit(fetch_url, 'http://www.baidu.com')

# 取出返回的结果

x = a.result()

print(x) # 获得百度的源码

6.全局解释器锁

尽管Python完全支持多线程编程, 但是解释器的C语言实现部分在完全并行执行时并不是线程安全的,实际上,解释器被一个全局解释器锁保护着 ,它确保任何时候都只有一个Python线程执行;

GIL最大的问题就是Python的多线程程序并不能利用多核CPU的优势, 就是因为GIL的存在,使得一个进程的多个线程在执行任务的时候,一个CPU时 间片内,只有一个线程能够调度到CPU上运行;

因此CPU密集型的程序一般不会使用Python实现,可以选择Java,GO等语言;

但是对于非CPU密集型程序,例如IO密集型程序,多数时间都是对网络IO的等待,因此Python的多线程完全可以胜任;

对于全局解释器锁的解决方案:

使用multiprocessing创建进程池对象,实现多进程并发,这样就能够使用多CPU计算资源;

使用C语言扩展,将计算密集型任务转移给C语言实现去处理,在C代码实现部分可以释放GIL;

多线程和多进程解决方案:

如果想要同时使用多线程和多进程,最好在程序启动时,创建任何线程之前,先创建一个单例的进程池, 然后线程使用同样的进程池来进行它们的计 算密集型工作,这样类似于线程调用了进程,完成了CPU密集型任务,进程也利用了多CPU的优势;

参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值