Python教程-Python 信号量

在以下教程中，我们将了解如何在Python中使用信号量进行多线程同步。

让我们从了解Python信号量开始。

了解信号量

1. 信号量是一种同步构造。
2. 信号量为线程提供对受限资源的同步访问。
3. 信号量可以被看作是反映当前存在的资源数量的变量。例如，购物中心停车场的某个级别上有几个可用的车位，这就是一个信号量。
4. 信号量的值不能小于零，也不能大于现有资源的总数。
5. 信号量与两个操作相关联 - 获取 和 释放。
6. 当线程使用信号量同步其中一个资源时，信号量的值会递减。
7. 当线程释放信号量同步的一个资源时，信号量的值会递增。
8. 信号量的概念由荷兰计算机科学家Edsger Dijkstra创建。
9. 信号量的两个操作，即 获取 和 释放，由Dijkstra分别表示为p和v，其中p和v是荷兰单词proberen和vehogen的首字母。
10. 单词proberen表示测试，而vehogen表示增加。

现在让我们了解Python编程语言中的信号量。

了解Python信号量

1. 在Python中，使用threading模块的一个类来实现信号量的概念。这个类称为Semaphore。
2. 信号量类包括一个构造函数和两个函数，acquire()和release()。
3. acquire()函数用于在计数大于零的情况下减少信号量的计数。否则，它会阻塞，直到计数大于零。
4. release()函数用于增加信号量的计数并唤醒等待信号量的线程之一。

让我们考虑以下语法，以创建信号量对象。

语法：

object_name = Semaphore(count) 

解释：

在上述语法中，object_name是Semaphore类的对象。Semaphore类的'count'参数是允许同时访问的线程数。该参数的默认值为1。

每当执行acquire()函数时，'count'参数的值将减少一个。每当执行release()函数时，'count'参数的值将增加一个。这意味着每当我们调用acquire()方法时，'count'参数值将递减，而在调用release()方法时，'count'参数值将递增。

创建信号量对象的方法

情况1： 在以下情况下，我们在创建对象时没有指定信号量类内的参数。因此，计数变量的值为1，因此只允许一个线程访问。这种情况与Lock概念完全相同。

下面是相同的语法：

语法：

object_name.Semaphore() 

情况2： 在以下情况下，信号量类的对象可以同时由n个线程访问。其余线程必须等待释放信号量。

下面是相同的语法：

语法：

object_name.Semaphore(n)  

让我们考虑以下示例，以更好地理解整个概念。

示例：

# importing the modules  
from threading import *           
import time          
    
# creating thread instance where count = 3  
my_obj = Semaphore(4)          
    
# creating instance  
def show(the_name):  
      
    # calling acquire method  
    my_obj.acquire()                  
    for n in range(6):  
        print('javatiku, ', end = '')  
        time.sleep(1)  
        print(the_name)  
            
        # calling release method  
        my_obj.release()      
            
# creating multiple thread   
thread_1 = Thread(target = show , args = ('Thread 1',))  
thread_2 = Thread(target = show , args = ('Thread 2',))  
thread_3 = Thread(target = show , args = ('Thread 3',))  
thread_4 = Thread(target = show , args = ('Thread 4',))  
thread_5 = Thread(target = show , args = ('Thread 5',))  
thread_6 = Thread(target = show , args = ('Thread 6',))  
  
# calling the threads   
thread_1.start()  
thread_2.start()  
thread_3.start()  
thread_4.start()  
thread_5.start()  
thread_6.start()  

输出

javatiku, javatiku, javatiku, javatiku, Thread 1
Thread 3
Thread 4
Thread 2
javatiku, javatiku, javatiku, javatiku, javatiku, javatiku, Thread 1
Thread 5
javatiku, javatiku, Thread 6
Thread 3
Thread 4
javatiku, javatiku, Thread 2
javatiku, javatiku, Thread 5
javatiku, Thread 1
javatiku, Thread 3
javatiku, Thread 6
Thread 2
Thread 4
javatiku, javatiku, javatiku, Thread 5
javatiku, Thread 1
javatiku, Thread 3
javatiku, Thread 6
Thread 2
javatiku, javatiku, Thread 4
javatiku, Thread 5
javatiku, Thread 1
Thread 3
javatiku, javatiku, Thread 2
Thread 6
javatiku, javatiku, Thread 4
javatiku, Thread 5
javatiku, Thread 1
Thread 3
Thread 2
Thread 6
javatiku, Thread 4
Thread 5
Thread 6

解释：

在上面的代码片段中，我们导入了所需的模块并为Semaphore类创建了一个计数值为4的对象。然后，我们定义了一个函数，使用对象上的acquire()函数。然后，我们使用for循环来迭代值到6。然后我们调用了release()函数并创建了多个线程。最后，我们使用start()函数调用了这些线程。