Semaphor控制资源访问的使用方法

Semaphore是java并发包中提供的用于控制某资源同时被访问的个数的类。Semaphore最重要的两个方法是acquire()和release()。acquire()用于获得访问资源的许可，该方法会阻塞直到有可访问的资源；release用于释放访问资源的许可。

本文给出一个示例，模拟300个线程去获取资源池中的资源，但资源池每次最多只能提供10个资源. 当线程使用完资源后，归还相应的资源，供其他线程继续使用. 

资源类源代码 -

package semaphore;

/**
 * 资源类
 * @author cclin
 *
 */
public class Resource {

    //资源名称
    private String resourceName;
    //资源状态,判断资源是否被占用
    private boolean busy;

    public Resource(String resourceName) {
        super();
        this.resourceName = resourceName;
    }

    public String getResourceName() {
        return resourceName;
    }

    public boolean isBusy() {
        return busy;
    }

    public void setBusy(boolean busy) {
        this.busy = busy;
    }
}

资源池源代码，基于信号量的资源访问 -

package semaphore;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;

/**
 * 资源池类
 * @author cclin
 *
 */
public class ResourcePool {

    // 资源数目
    private static final int RESOURCE_SIZE = 10;
    // 构建资源集合
    private List<Resource> resources = new ArrayList<Resource>(){{
        for(int i=0;i<RESOURCE_SIZE;i++){
            add(new Resource("资源"+i));
        }
    }};
    // 控制资源范围的信号量，最多只能提供 RESOURCE_SIZE 个资源被访问
    private Semaphore semaphore = new Semaphore(RESOURCE_SIZE);
    
    /**
     * 获取资源
     * @return
     * @throws InterruptedException
     */
    public Resource fetchResource() throws InterruptedException{
        //获取访问资源的许可
        semaphore.acquire();
        Resource rs = null;
        for(Resource resource : resources){
            if(!resource.isBusy()){
                //返回一个空闲资源
                rs = resource;
                //设置资源状态
                rs.setBusy(true);
                System.out.println("资源池分配"+rs.getResourceName());
                break;
            }
        }
        return rs;
    }
    
    /**
     * 释放资源
     */
    public void releaseResource(Resource resource){
        //设置资源状态
        resource.setBusy(false);
        System.out.println("资源池回收"+resource.getResourceName());
        //释放一个资源许可
        semaphore.release();
    }
}

资源消费者源代码 - 

package semaphore;

/**
 * 资源消费者类
 * @author cclin
 *
 */
public class Consumer implements Runnable  {

    /**
     * 消费者名称
     */
    private String consumerName;
    
    /**
     * 资源池
     */
    private ResourcePool rsPool;
    
    public Consumer(String consumerName, ResourcePool rsPool) {
        super();
        this.consumerName = consumerName;
        this.rsPool = rsPool;
        System.out.println("创建了"+consumerName);
    }

    /**
     * 使用资源池中分配的资源
     * @param rsPool
     */
    public void consumeResourceFromPool(){
        //从资源池中获取资源
        try {
            Resource rs = rsPool.fetchResource();
            if(rs!=null){
                //使用资源
                System.out.println(consumerName+"正在使用"+rs.getResourceName());
                Thread.sleep(5000);
                //使用完毕，释放资源
                System.out.println(consumerName+"使用"+rs.getResourceName()+"完毕");
                rsPool.releaseResource(rs);
            }
            else{
                System.out.println(consumerName+"无法获得任何资源！");
            }
            
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        consumeResourceFromPool();
    }
}

测试代码 - 

package semaphore;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SemaphoreTest {

    public static void main(String[]args){
        //创建线程池
        ExecutorService executorService = Executors.newCachedThreadPool();  
        ResourcePool rsPool = new ResourcePool();
        for (int i = 0; i <= 300; i++) {  
            executorService.submit(new Consumer("消费者"+i, rsPool));  
        }
        executorService.shutdown();  
    }
}