随笔--实现一个对象池，例如线程池使用信号量

最新推荐文章于 2024-04-04 00:40:24 发布

茄子_土豆

最新推荐文章于 2024-04-04 00:40:24 发布

阅读量128

点赞数

分类专栏：随笔

本文链接：https://blog.csdn.net/weixin_41955327/article/details/118399337

版权

随笔专栏收录该内容

14 篇文章 0 订阅

订阅专栏

该博客介绍了一个使用Semaphore管理资源池的Java实现。PoolSemaphore类包含了一个可用资源和不可用资源的信号量，以及一个资源池。通过initResource初始化资源，takeResource获取资源，returnResource归还资源。在测试类中创建了50个线程并发地从资源池中获取和归还资源，展示了Semaphore在多线程环境下控制并发访问的有效性。

摘要由CSDN通过智能技术生成

package com.mytest.semaphore;

import java.util.LinkedList;
import java.util.concurrent.Semaphore;

/**
 * @ClassName: TestSemaphore
 * @Description:
 * @Author fjp
 * @Date 2021/7/1-9:53
 * @Version 1.0
 */
public class PoolSemaphore<T> {

    private final Semaphore usefull;
    private final Semaphore useless;
    private LinkedList<T> pool;
    private static Object LOCK = new Object();




    private void initResource(ManageResource t, int size) {
        for (int i1 = 0; i1 < size; i1++) {
            pool.add((T) t.getResource());
        }
    }

    public PoolSemaphore(ManageResource t, int size) {
        this.usefull = new Semaphore(size);
        this.useless = new Semaphore(0);
        pool = new LinkedList<>();
        initResource(t, size);
    }


    interface ManageResource<T> {
        T getResource();
    }


    public void returnResource(T t) throws InterruptedException {
        if (t != null) {
            useless.acquire();
            synchronized (LOCK) {
                pool.addLast(t);
              //  System.out.println("size最大为2，poolSize:"+pool.size());
            }
            usefull.release();
        }
    }


    public T takeResource() throws InterruptedException {
        usefull.acquire();
        T t=null;
        synchronized (LOCK) {
            try {
                t = pool.removeFirst();
               // System.out.println("size最小为0，poolSize:"+pool.size());
            }catch (Exception e){
                
                e.printStackTrace();
            }
        }
        useless.release();
        return t;
    }

}

测试类

package com.mytest.semaphore;

import org.junit.Test;

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

/**
 * @ClassName: TestPoolSemaphore
 * @Description:
 * @Author fjp
 * @Date 2021/7/1-10:53
 * @Version 1.0
 */
public class TestPoolSemaphore {


    @Test
    public void test() throws InterruptedException {
        ExecutorService poolThread = Executors.newFixedThreadPool(50);
        //池中放了了两个资源
        PoolSemaphore<Resource> resourcePoolSemaphore = new PoolSemaphore<>(() -> {
            return new Resource(1, "1");
        }, 2);
        for (int i = 0; i < 50; i++) {
            poolThread.submit(() -> {
                try {
                    Resource resource = resourcePoolSemaphore.takeResource();
                    // todo  100ms work
                    Thread.sleep(100);
                    resourcePoolSemaphore.returnResource(resource);
                } catch (InterruptedException e) {
                    System.out.println("error" + e.getMessage());
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(100000);
    }


   
    class Resource implements PoolSemaphore.ManageResource<Integer> {


        @Override
        public Integer getResource() {
            return null;
        }


        private Integer i;
        private String name;

        public Resource(Integer i, String name) {
            this.i = i;
            this.name = name;
        }

 

    }
 
}