日本网站代理/友情链接名词解释

我们可以使用信号量来锁定对资源的访问，每个想要使用该资源的线程在访问资源之前必须首先调用acquire()方法来获取锁。当线程不再需要资源时，它必须调用release()方法来释放锁。这里有个例子来说明：

// java program to demonstrate  
// use of semaphores Locks 
import java.util.concurrent.*; //A shared resource/class. 
class Shared  
{ static int count = 0; 
} class MyThread extends Thread 
{ Semaphore sem; String threadName; public MyThread(Semaphore sem, String threadName)  { super(threadName); this.sem = sem; this.threadName = threadName; } @Overridepublic void run() { // run by thread A if(this.getName().equals("A")) { System.out.println("Starting " + threadName); try { // 首先获取许可System.out.println(threadName + " is waiting for a permit."); // 获取锁 sem.acquire(); System.out.println(threadName + " gets a permit."); // 访问共享资源 // 其他等待线程会一直等到次线程释放锁  for(int i=0; i < 5; i++) { Shared.count++; System.out.println(threadName + ": " + Shared.count); // 允许上下文切换// 让线程B运行 Thread.sleep(10); } } catch (InterruptedException exc) { System.out.println(exc); } // 释放许可 System.out.println(threadName + " releases the permit."); sem.release(); } // run by thread B else{ System.out.println("Starting " + threadName); try { // First, get a permit. System.out.println(threadName + " is waiting for a permit."); // acquiring the lock sem.acquire(); System.out.println(threadName + " gets a permit."); // Now, accessing the shared resource. // other waiting threads will wait, until this  // thread release the lock for(int i=0; i < 5; i++) { Shared.count--; System.out.println(threadName + ": " + Shared.count); // Now, allowing a context switch -- if possible. // for thread A to execute Thread.sleep(10); } } catch (InterruptedException exc) { System.out.println(exc); } // Release the permit. System.out.println(threadName + " releases the permit."); sem.release(); } } 
} // Driver class 
public class SemaphoreDemo  
{ public static void main(String args[]) throws InterruptedException  { // 创建一个Semaphore对象// 许可数设置为1 Semaphore sem = new Semaphore(1); // 创建名为A和B的两个线程 // 注意，线程A将递增count // 线程B将递减count MyThread mt1 = new MyThread(sem, "A"); MyThread mt2 = new MyThread(sem, "B"); // 启动线程A和B.mt1.start(); mt2.start(); // 等待线程A和B.  mt1.join(); mt2.join(); //两个线程都完成执行后count会始终为0System.out.println("count: " + Shared.count); } 
} 

输出：

Starting A
A is waiting for a permit.
A gets a permit.
A: 1
Starting B
B is waiting for a permit.
A: 2
A: 3
A: 4
A: 5
A releases the permit.
B gets a permit.
B: 4
B: 3
B: 2
B: 1
B: 0
B releases the permit.
count: 0

注意：在上述程序的不同执行中输出可能不同，但count变量的最终值将始终保持为0。

解释：

• 程序使用信号量来控制对count变量的访问，count变量是Shared类中的静态变量。Shared.count由线程A递增五次，并由线程B递减五次。为了防止这两个线程同时访问Shared.count，只有在从控制信号量获取许可后才允许访问。访问完成后，许可将被释放。这样，一次只有一个线程将访问Shared.count，如输出所示。
• 注意在MyThread类中的run()方法中调用sleep()方法，用于“证明”对Shared.count的访问被信号量同步了。在run()方法中，对sleep()的调用会导致线程在每次访问Shared.count之间暂停。这通常会使另一个线程运行。然而，由于信号量，第二个线程必须等到第一个线程释放许可，这只有在第一个线程的所有访问完成后才会发生。因此，Shared.count首先由线程A递增五次，然后由线程B递减五次。递增和递减不会在汇编代码中交叉执行。
• 如果不使用信号量，两个线程对Shared.count的访问将同时发生，递增和递减会交叉执行。要确认这一点，可以尝试注释acquire()和release()。运行程序时，会看到对Shared.count的访问不再同步，因此不会始终获得计数值为0。