在本教程中，我们将在Java中看到java的信号量。

Semaphore是Java.util.concurrent包中的程序。
在JDK 5.信号量基本上维护了一组允许，因此有两种方法主要用于信号量。

• acquire
• release

acquire()方法用于获得许可，如果不是。
许可证达到Max允许的许可，然后线程必须等待获取允许通过调用Release()方法来由某些其他线程释放的许可。

信号量通常用于限制访问资源的线程数。

实时示例：

• 信号量可用于一次限制数据库连接的数量
• 信号量也可用于绑定任何收集。

例子：

我们将创建一个CloundedArrayList，一次只能拥有5个元素。
如果任何线程想要将更多元素添加到列表中，则线程将必须等到任何其他线程从列表中删除元素。

当我们向列表添加一个元素时，我们将调用Semaphore.acquire，当我们从列表中删除一个元素时，我们将调用信号量。
详细信息。

创建一个名为buneredArrayList的类。

package org.igi.theitroad.bean;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.Semaphore;
 
public class BoundedArrayList {
 
 private final Semaphore semaphore;
 private List arraylist;
 
 BoundedArrayList(int limit) {
 this.arraylist = Collections.synchronizedList(new ArrayList());
 semaphore = new Semaphore(limit);
 }
 
 /*
 * Add element to the list and call semaphore.acquire method
 * */
 public boolean add(T t) throws InterruptedException {
 boolean added = false;
 semaphore.acquire();
 try {
 added = arraylist.add(t);
 return added;
 } finally {
 if (!added)
 semaphore.release();
 }
 
 }
 
 /*
 * remove element from the list and call semaphore.release method
 * */
 public boolean remove(T t) {
 boolean wasRemoved = arraylist.remove(t);
 if (wasRemoved)
 semaphore.release();
 return wasRemoved;
 }
 
 public void remove(int index) {
 arraylist.remove(index);
 semaphore.release();
 }
 
 public List getArraylist() {
 return arraylist;
 }
 
 
 public Semaphore getSemaphore() {
 return semaphore;
 }
}

创建一个主类BuindedArrayListmain.java

package org.igi.theitroad.bean;
 
public class BoundedArrayListMain {
 
 public static void main(String[] args) throws InterruptedException {
 
  final BoundedArrayList ba = new BoundedArrayList(5);
  Runnable runnable1 = new Runnable() {
 
   @Override
   public void run() {
    try {
     ba.add("John");
     ba.add("Martin");
     ba.add("Adam");
     ba.add("Prince");
     ba.add("Tod");
     System.out.println("Available Permits : "+ba.getSemaphore().availablePermits());
     ba.add("Tony");
     System.out.println("Final list: "+ba.getArraylist());
    } catch (InterruptedException ie) {
 
    }
   }
  };
  Runnable runnable2 = new Runnable() {
   @Override
   public void run() {
    try {
     System.out.println("Before removing elements: "+ ba.getArraylist());
     Thread.sleep(5000);
     ba.remove("Martin");
     ba.remove("Adam");
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  };
 
  Thread t1 = new Thread(runnable1);
  Thread t2 = new Thread(runnable2);
  t1.start();
  t2.start();
 }
 
}

运行上面的程序时，我们将得到以下输出：

Available Permits : 0
Before removing elements: [John, Martin, Adam, Prince, Tod]
Final list: [John, Prince, Tod, Tony]

解释：

• 我们创建了两个线程t1和t2.
• T1和T2都共享公共列表参考BA。
• 当T1将5个元素添加到列表中时，可用许可证变为0。
• 现在T1等待另一个线程删除元素，以便信号量有一些可用的许可。
• 在等待5秒后，另一个线程T2从列表中删除元素。
• 一旦T2删除元素，T1将"Tony"添加到列表中。