池化技术（对象池）_代码007(未授权)

本文介绍: 池化技术是一种很常见的编程技巧，目的在于提前创建如内存，对象，线程资源，降低程序运行时频繁的创建销毁带来的开销。常见的有线程池，内存池，对象池等。池化技术如何提高性能，降低系统开销在实际的应用中，程序经常需要创建对象，线程和分配内存。这些设计到系统调用，系统调用会导致程序从用户态到内核态的切换会比较耗时。有了池化技术，需要用到对应的线程，对象和内存时不需要再切换上下文之需要从相应的池中获取，也不需要销毁，用完归还即可。线程池实现的原理。

池化技术是一种很常见的编程技巧，目的在于提前创建如内存，对象，线程资源，降低程序运行时频繁的创建销毁带来的开销。常见的有线程池，内存池，对象池等。

池化技术如何提高性能，降低系统开销

在实际的应用中，程序经常需要创建对象，线程和分配内存。这些设计到系统调用，系统调用会导致程序从用户态到内核态的切换会比较耗时。有了池化技术，需要用到对应的线程，对象和内存时不需要再切换上下文之需要从相应的池中获取，也不需要销毁，用完归还即可。

线程池实现的原理

先启动若干线程让其处于休眠状态/当用户中的系统需要访问时，从线程池中拿出一个已建立的空闲的连接，使用完毕后不关闭连接而是归还到线程池中。

数据库连接池的重要配置：最大连接数和最小连接数

public interface HousePool {
    // 创建
    House getHouse();
    // 归还
    void release(House po);
    //初始化
    void init();
}

@Service
public class HousePoolImpl implements HousePool{
    // 维护两个池子
    private LinkedBlockingQueue&lt;House&gt; idle ;
    private LinkedBlockingQueue&lt;House&gt; busy ;
    //维护池中的对象数量
    private final  int maxSize = 10 ;
    private AtomicInteger busySize = new AtomicInteger(0) ;

    @Override
    public void init() {
         idle = new LinkedBlockingQueue<>();
         busy = new LinkedBlockingQueue<>();
    }

    @Override
    public House getHouse() {
        // 创建对象池
        House po = null;
        po = idle.poll();
        // 有空闲对象 直接用
        if(po != null){
            busy.offer(po);
            return po;
        }
        // 未满 创建
        if(busySize.get() < maxSize){
            if(busySize.incrementAndGet() <= maxSize){
                System.out.println("创建House");
                po = new House();
                busy.offer(po);
                return po;
            }
        }
        // 已满等待或超时报错
        try {
            idle.poll(10000, TimeUnit.MILLISECONDS);
            if(po ==null){
                   throw  new RuntimeException("超时");
            }
            busy.offer(po);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return po;
    }

    @Override
    public void release(House po) {
        busy.remove(po);
        idle.offer(po);
    }
}

@Configuration
public class PoolConfiguration {

    @Bean
    public  HousePool housePool(){
        HousePoolImpl housePool = new HousePoolImpl();
        housePool.init();
        return housePool;
    }
}

 private AtomicInteger busySize = new AtomicInteger(0) ;
  if(busySize.get() < maxSize){
        if(busySize.incrementAndGet() <= maxSize){
           System.out.println("创建House");
            po = new House();
            busy.offer(po);
            return po;
         }
   }

// 已满等待或超时报错
        try {
            idle.poll(10000, TimeUnit.MILLISECONDS);
            if(po ==null){
                   throw  new RuntimeException("超时");
            }
            busy.offer(po);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

 @Test
    void testOrigin() {
        housePool.init();
        int i = 0 ;
        while(i < 10){
            House house = housePool.getHouse();
            System.out.println("得到hosue");
            housePool.release(house);
            i++;
        }
    }