org.redkale.util.ObjectPool Maven / Gradle / Ivy

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.redkale.util;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.function.*;
import java.util.logging.*;

/**
 * 对象池
 *
 * 
 * 详情见: https://redkale.org
 *
 * @author zhangjx
 * @param  对象池元素的数据类型
 */
public final class ObjectPool implements Supplier, Consumer {

    private static final Logger logger = Logger.getLogger(ObjectPool.class.getSimpleName());

    private final boolean debug;

    private final Queue queue;

    private Creator creator;

    private final Consumer prepare;

    private final Predicate recycler;

    private final AtomicLong creatCounter;

    private final AtomicLong cycleCounter;

    public ObjectPool(Class clazz, Consumer prepare, Predicate recycler) {
        this(2, clazz, prepare, recycler);
    }

    public ObjectPool(int max, Class clazz, Consumer prepare, Predicate recycler) {
        this(max, Creator.create(clazz), prepare, recycler);
    }

    public ObjectPool(Creator creator, Consumer prepare, Predicate recycler) {
        this(2, creator, prepare, recycler);
    }

    public ObjectPool(int max, Creator creator, Consumer prepare, Predicate recycler) {
        this(null, null, max, creator, prepare, recycler);
    }

    public ObjectPool(int max, Supplier creator, Consumer prepare, Predicate recycler) {
        this(null, null, max, creator, prepare, recycler);
    }

    public ObjectPool(AtomicLong creatCounter, AtomicLong cycleCounter, int max, Supplier creator, Consumer prepare, Predicate recycler) {
        this(creatCounter, cycleCounter, max, c -> creator.get(), prepare, recycler);
    }

    public ObjectPool(AtomicLong creatCounter, AtomicLong cycleCounter, int max, Creator creator, Consumer prepare, Predicate recycler) {
        this.creatCounter = creatCounter;
        this.cycleCounter = cycleCounter;
        this.creator = creator;
        this.prepare = prepare;
        this.recycler = recycler;
        this.queue = new LinkedBlockingQueue<>(Math.max(Runtime.getRuntime().availableProcessors() * 2, max));
        this.debug = logger.isLoggable(Level.FINEST);
    }

    public void setCreator(Creator creator) {
        this.creator = creator;
    }

    public Predicate getRecyclerPredicate() {
        return recycler;
    }

    @Override
    public T get() {
        T result = queue.poll();
        if (result == null) {
            if (creatCounter != null) creatCounter.incrementAndGet();
            result = this.creator.create();
        }
        if (prepare != null) prepare.accept(result);
        return result;
    }

    @Override
    public void accept(final T e) {
        if (e != null && recycler.test(e)) {
            if (cycleCounter != null) cycleCounter.incrementAndGet();
//            if (debug) {
//                for (T t : queue) {
//                    if (t == e) {
//                        logger.log(Level.WARNING, "[" + Thread.currentThread().getName() + "] repeat offer the same object(" + e + ")", new Exception());
//                        return;
//                    }
//                }
//            }
            queue.offer(e);
        }
    }

    public long getCreatCount() {
        return creatCounter.longValue();
    }

    public long getCycleCount() {
        return cycleCounter.longValue();
    }
}