java.util.concurrent.Semaphore 使用
1. 概述
Semaphore(信号) 并不存在真正的许可 只是维护一个计数器, 通常用来限定进入一些资源的线程数
accquire() 方法获取许可 成功则计数器值-1 没有则阻塞直到一个可用的许可(即计数器>0)
release() 方法 潜在的释放了申请人(通过给计数器值+1)
2. 示例一(单独测试信号量增减 availabelPermits对超出数量的线程的阻塞)
package com.rocky.semaphore; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class SemaphoreTest { public static void main(String[] args) { Semaphore semaphore = new Semaphore(5, false);//no fair 并行最大为5,阻塞后来的 ExecutorService service = Executors.newCachedThreadPool(); for(int i=0; i<10; i++){ service.execute(new Worker(semaphore)); } service.shutdown(); } } class Worker implements Runnable{ private Semaphore semaphore; Worker(Semaphore semaphore){ this.semaphore = semaphore; } @Override public void run() { try { semaphore.acquire();//获取许可 try { System.out.println(Thread.currentThread().getName()+" accessing..."); Thread.sleep((long) (Math.random()*3000)); } finally{ semaphore.release();//释放许可 System.out.println(Thread.currentThread().getName()+" leaving..."); } } catch (InterruptedException e) { e.printStackTrace(); } }}
说明： 默认是非公平的 进来一个线程获取许可, 则state减1，直到值为0 以下是源码片段
final int nonfairTryAcquireShared(int acquires) {//acquires值为1 for (;;) { int available = getState();//当前state值 int remaining = available - acquires; if (remaining < 0 || compareAndSetState(available, remaining))//remaining>0 则CAS修改state 成功获取许可 return remaining; } } //remainimg<0 返回后,执行下面方法 private void doAcquireSharedInterruptibly(int arg) throws InterruptedException { final Node node = addWaiter(Node.SHARED);//创建共享型节点加入等待队列 队列为空则仿制头结点并建立联系 try { for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg);//再次尝试获取许可 if (r >= 0) {//成功获取许可 setHeadAndPropagate(node, r); p.next = null; // help GC return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) break; } } catch (RuntimeException ex) { cancelAcquire(node); throw ex; } // Arrive here only if interrupted cancelAcquire(node); throw new InterruptedException(); }
3. 示例二(一个生产者与一个消费者 两组信号量 此消彼长 为0阻塞)
package com.rocky.semaphore; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class ProducerCustomRealizeWithSemaphore { public static void main(String[] args) { SemaphoreBuffer semaphoreBuffer = new SemaphoreBuffer(); Producer producer = new Producer(semaphoreBuffer); Customer customer = new Customer(semaphoreBuffer); ExecutorService service = Executors.newCachedThreadPool(); service.execute(customer); service.execute(producer); service.shutdown(); } } class SemaphoreBuffer{ List<Integer> list = new ArrayList<Integer>(); Semaphore producerSemaphore = new Semaphore(1);// 允许并行的线程数为1 Semaphore customerSemaphore = new Semaphore(0);// 0即state的初始值 则一开始消费就阻塞了 见上例说明中remaining<0 public void put(int num){ try { producerSemaphore.acquire(); try { list.add(num); } finally{ customerSemaphore.release(); } } catch (InterruptedException e) { e.printStackTrace(); } } public int get(){ try { customerSemaphore.acquire(); try{ return list.remove(0); }finally{ producerSemaphore.release(); } } catch (InterruptedException e) { e.printStackTrace(); } return 0; } } class Customer implements Runnable{ private SemaphoreBuffer buffer; Customer(SemaphoreBuffer buffer){ this.buffer = buffer; } @Override public void run() { while(!Thread.interrupted()){ int num = buffer.get(); System.out.println("Customer get the num "+num); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Producer implements Runnable{ private SemaphoreBuffer buffer; Producer(SemaphoreBuffer buffer){ this.buffer = buffer; } int c =0; @Override public void run() { while(!Thread.interrupted()){ buffer.put(c); System.out.println("Producer put the num "+c); c++; try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
4. 示例三(多个生产者与多个消费者 运用阻塞队列 线程安全 )
package com.rocky.semaphore; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.Semaphore; import java.util.concurrent.atomic.AtomicInteger; public class ProducerCustomRealizeWithSemaphoreLinkedBlockingQueue { static AtomicInteger c = new AtomicInteger(1); public static void main(String[] args) { ExecutorService service = Executors.newCachedThreadPool(); CakeStand stand = new CakeStand(); service.execute(new CakeProducer(stand, "producer1", c)); service.execute(new CakeProducer(stand, "producer2", c)); service.execute(new CakeProducer(stand, "producer3", c)); service.execute(new CakeCustomer(stand, "customer1")); service.execute(new CakeCustomer(stand, "customer2")); } } class Cake{ private String name; Cake(String name){ this.name = name; } public String toString(){ return name; } } class CakeStand{ BlockingQueue<Cake> queue = new LinkedBlockingQueue<Cake>(15); Semaphore notFull = new Semaphore(10);//生产信号量 Semaphore notEmpty = new Semaphore(0);//消费信号量 public void put(Cake cake){ try { notFull.acquire(); try{ queue.put(cake); }finally{ notEmpty.release(); } } catch (InterruptedException e) { e.printStackTrace(); } } public Cake take(){ try { notEmpty.acquire(); try{ Cake cake = queue.take(); return cake; }finally{ notFull.release(); } } catch (InterruptedException e) { e.printStackTrace(); } return null; } } class CakeProducer implements Runnable{ private CakeStand stand; private String name; private AtomicInteger c; public CakeProducer(CakeStand stand, String name, AtomicInteger c) { this.stand = stand; this.name = name; this.c = c; } @Override public void run() { while(!Thread.interrupted()){ String str = "cake-"+c.getAndIncrement(); System.out.println("生产:"+name+"-"+str); stand.put(new Cake(str)); try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } } } } class CakeCustomer implements Runnable{ private CakeStand stand; private String name; public CakeCustomer(CakeStand stand, String name){ this.stand = stand; this.name = name; } @Override public void run() { while(!Thread.interrupted()){ Cake cake = stand.take(); System.err.println("消费:"+name+"-"+cake.toString()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
说明1)： 传统的消费者 生产者使用wait/notify模式等待和相互唤醒， Semaphore通过信号量的值控制运行(>0)和阻塞(<=0),
两组信号量可以使两组角色彼此唤醒，使用阻塞队列可以确保线程安全。
2) 可以额外创建一个信号量Semaphore mutex = new Semaphore(1); 在获取本组信号量之后再获取metex信号量可以实现互斥锁效果
