栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

netty Recycler对象回收

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

netty Recycler对象回收


netty Recycler对象回收

          

                  

                                   

相关类与接口

          

Recycler:对象重复使用

public abstract class Recycler {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(Recycler.class);
    private static final Recycler.Handle NOOP_HANDLE = new Recycler.Handle() {
        public void recycle(Object object) {
        }

        public String toString() {
            return "NOOP_HANDLE";
        }
    };
    private static final int DEFAULT_INITIAL_MAX_CAPACITY_PER_THREAD = 4096;
    private static final int DEFAULT_MAX_CAPACITY_PER_THREAD;
    private static final int RATIO;
    private static final int DEFAULT_QUEUE_CHUNK_SIZE_PER_THREAD;
    private static final boolean BLOCKING_POOL;
    private final int maxCapacityPerThread;   //每个线程最大存储的对象数
    private final int interval;
    private final int chunkSize;
    private final FastThreadLocal> threadLocal;

    protected Recycler() {
        this(DEFAULT_MAX_CAPACITY_PER_THREAD);
    }

    protected Recycler(int maxCapacityPerThread) {
        this(maxCapacityPerThread, RATIO, DEFAULT_QUEUE_CHUNK_SIZE_PER_THREAD);
    }

    protected Recycler(int maxCapacityPerThread, int ratio, int chunkSize) {
        this.threadLocal = new FastThreadLocal>() {
            protected Recycler.LocalPool initialValue() {
                return new Recycler.LocalPool(Recycler.this.maxCapacityPerThread, Recycler.this.interval, Recycler.this.chunkSize);
            }

            protected void onRemoval(Recycler.LocalPool value) throws Exception {
                super.onRemoval(value);
                MessagePassingQueue> handles = value.pooledHandles;
                value.pooledHandles = null;
                handles.clear();
            }
        };
        this.interval = Math.max(0, ratio);
        if (maxCapacityPerThread <= 0) {
            this.maxCapacityPerThread = 0;
            this.chunkSize = 0;
        } else {
            this.maxCapacityPerThread = Math.max(4, maxCapacityPerThread);
            this.chunkSize = Math.max(2, Math.min(chunkSize, this.maxCapacityPerThread >> 1));
        }

    }

    public final T get() {     //获取回收池里的对象
        if (this.maxCapacityPerThread == 0) {  //如果maxCapacityPerThread为0,创建新的对象
            return this.newObject(NOOP_HANDLE);
        } else {      //maxCapacityPerThread不为0,尝试从回收池里获取对象
            Recycler.LocalPool localPool = (Recycler.LocalPool)this.threadLocal.get();
            Recycler.DefaultHandle handle = localPool.claim();
            Object obj;
            if (handle == null) {
                handle = localPool.newHandle();
                if (handle != null) {
                    obj = this.newObject(handle);
                    handle.set(obj);
                } else {
                    obj = this.newObject(NOOP_HANDLE);
                }
            } else {
                obj = handle.get();
            }

            return obj;
        }
    }


    final int threadLocalSize() {
        return ((Recycler.LocalPool)this.threadLocal.get()).pooledHandles.size();
    }

    protected abstract T newObject(Recycler.Handle var1);  //创建新的对象

    static {
        int maxCapacityPerThread = SystemPropertyUtil.getInt("io.netty.recycler.maxCapacityPerThread", SystemPropertyUtil.getInt("io.netty.recycler.maxCapacity", 4096));
        if (maxCapacityPerThread < 0) {
            maxCapacityPerThread = 4096;
        }

        DEFAULT_MAX_CAPACITY_PER_THREAD = maxCapacityPerThread;
        DEFAULT_QUEUE_CHUNK_SIZE_PER_THREAD = SystemPropertyUtil.getInt("io.netty.recycler.chunkSize", 32);
        RATIO = Math.max(0, SystemPropertyUtil.getInt("io.netty.recycler.ratio", 8));
        BLOCKING_POOL = SystemPropertyUtil.getBoolean("io.netty.recycler.blocking", false);
        if (logger.isDebugEnabled()) {
            if (DEFAULT_MAX_CAPACITY_PER_THREAD == 0) {
                logger.debug("-Dio.netty.recycler.maxCapacityPerThread: disabled");
                logger.debug("-Dio.netty.recycler.ratio: disabled");
                logger.debug("-Dio.netty.recycler.chunkSize: disabled");
                logger.debug("-Dio.netty.recycler.blocking: disabled");
            } else {
                logger.debug("-Dio.netty.recycler.maxCapacityPerThread: {}", DEFAULT_MAX_CAPACITY_PER_THREAD);
                logger.debug("-Dio.netty.recycler.ratio: {}", RATIO);
                logger.debug("-Dio.netty.recycler.chunkSize: {}", DEFAULT_QUEUE_CHUNK_SIZE_PER_THREAD);
                logger.debug("-Dio.netty.recycler.blocking: {}", BLOCKING_POOL);
            }
        }

    }


**********
内部类:Recycler.BlockingMessageQueue

    private static final class BlockingMessageQueue implements MessagePassingQueue {
        private final Queue deque;
        private final int maxCapacity;

        BlockingMessageQueue(int maxCapacity) {
            this.maxCapacity = maxCapacity;
            this.deque = new ArrayDeque();
        }

        public synchronized T poll() {
        public synchronized T peek() {
        public synchronized int size() {
        public synchronized void clear() {
        public synchronized boolean isEmpty() {
        public synchronized boolean offer(T e) {

        public int capacity() {

        public T relaxedPoll() {
        public T relaxedPeek() {
        public boolean relaxedOffer(T e) {

        public int drain(Consumer c) {
        public int drain(Consumer c, int limit) {
        public void drain(Consumer c, WaitStrategy wait, ExitCondition exit) {

        public int fill(Supplier s) {
        public int fill(Supplier s, int limit) {
        public void fill(Supplier s, WaitStrategy wait, ExitCondition exit) {


**********
内部类:Recycler.LocalPool

    private static final class LocalPool {
        private final int ratioInterval;
        private volatile MessagePassingQueue> pooledHandles;
        private int ratioCounter;

        LocalPool(int maxCapacity, int ratioInterval, int chunkSize) {

 
        void release(Recycler.DefaultHandle handle) {

        Recycler.DefaultHandle claim() {
        Recycler.DefaultHandle newHandle() {


**********
内部类:Recycler.DefaultHandle

    private static final class DefaultHandle implements Recycler.Handle {
        private static final int STATE_CLAIMED = 0;
        private static final int STATE_AVAILABLE = 1;
        private static final AtomicIntegerFieldUpdater> STATE_UPDATER;
        private volatile int state;
        private final Recycler.LocalPool localPool;
        private T value;

        DefaultHandle(Recycler.LocalPool localPool) {
            this.localPool = localPool;
        }

        public void recycle(Object object) {
            if (object != this.value) {
                throw new IllegalArgumentException("object does not belong to handle");
            } else {
                this.localPool.release(this);
            }
        }

        T get() {
        boolean availableToClaim() {

        void set(T value) {
        void toAvailable() {

        static {
            AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater(Recycler.DefaultHandle.class, "state");
            STATE_UPDATER = updater;
        }
    }


**********
内部接口:Recycler.Handle

    public interface Handle extends io.netty.util.internal.ObjectPool.Handle {
    }
}
 

           

ObjectPool

public abstract class ObjectPool {
    ObjectPool() {
    }

    public abstract T get();

    public static  ObjectPool newPool(ObjectPool.ObjectCreator creator) {
        return new ObjectPool.RecyclerObjectPool((ObjectPool.ObjectCreator)ObjectUtil.checkNotNull(creator, "creator"));
    }


*********
内部类:ObjectPool.RecyclerObjectPool

    private static final class RecyclerObjectPool extends ObjectPool {
        private final Recycler recycler;

        RecyclerObjectPool(final ObjectPool.ObjectCreator creator) {
            this.recycler = new Recycler() {
                protected T newObject(io.netty.util.Recycler.Handle handle) {
                    return creator.newObject(handle);
                }
            };
        }

        public T get() {
            return this.recycler.get();
        }
    }


*********
内部接口:ObjectPool.ObjectCreator

    public interface ObjectCreator {
        T newObject(ObjectPool.Handle var1);
    }


*********
内部接口:ObjectPool.Handle

    public interface Handle {
        void recycle(T var1);
    }
}

        

                

                                    

使用示例

    

Test

@Data
class Person{

    private String name;
    private Integer age;
    private Recycler.Handle handle;

    public Person(String name, Integer age){
        this.name = name;
        this.age = age;
    }

    public Person(String name, Integer age, Recycler.Handle handle){
        this.name = name;
        this.age = age;
        this.handle = handle;
    }

    public Person(Person person, Recycler.Handle handle){
        this.name = person.name;
        this.age = person.age;
        this.handle = handle;
    }

    public void recycle(){
        handle.recycle(this);
    }
}

public class Test3 {

    private static final Person person = new Person("瓜田李下",20);
    private static final Recycler recycler = new Recycler() {
        @Override
        protected Person newObject(Handle handle) {
            return new Person(person,handle);
        }
    };

    public static void fun(){   //同一个线程回收
        Person person = recycler.get();
        System.out.println(person);
        person.recycle();

        Person person2 = recycler.get();
        System.out.println(person2);
        person2.recycle();

        System.out.println("fun ==> "+person.equals(person2));
    }

    public static void fun2() {  //同一个线程不回收
        Person person = recycler.get();
        System.out.println(person);

        Person person2 = recycler.get();
        System.out.println(person2);
        person2.recycle();

        System.out.println("fun2 ==> "+person.equals(person2));
    }

    public static void fun3(){     //不同线程回收
        Person person =recycler.get();
        new Thread(() -> {
            person.recycle();
            System.out.println(person);
        }).start();

        try {
            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }

        Person person2 = recycler.get();
        System.out.println(person2);
        person2.recycle();

        System.out.println("fun3 ==> "+person.equals(person2));
    }

    public static void main(String[] args) {
        fun();
        fun2();
        fun3();
    }
}

        

fun ==> 控制台输出:

Person(name=瓜田李下, age=20, handle=io.netty.util.Recycler$DefaultHandle@33e5ccce)
Person(name=瓜田李下, age=20, handle=io.netty.util.Recycler$DefaultHandle@33e5ccce)
fun ==> true

               

fun2 ==> 控制台输出:

Person(name=瓜田李下, age=20, handle=io.netty.util.Recycler$DefaultHandle@33e5ccce)
Person(name=瓜田李下, age=20, handle=NOOP_HANDLE)
fun2 ==> false

             

fun3 ==> 控制台输出:

Person(name=瓜田李下, age=20, handle=io.netty.util.Recycler$DefaultHandle@33e5ccce)
Person(name=瓜田李下, age=20, handle=io.netty.util.Recycler$DefaultHandle@33e5ccce)
fun3 ==> true

                  

同一对象连续多次回收会报错

Exception in thread "main" java.lang.IllegalStateException: Object has been recycled already.
	at io.netty.util.Recycler$DefaultHandle.toAvailable(Recycler.java:252)
	at io.netty.util.Recycler$LocalPool.release(Recycler.java:287)
	at io.netty.util.Recycler$DefaultHandle.recycle(Recycler.java:231)
	at com.example.demo.test.Person.recycle(Test3.java:31)
	at com.example.demo.test.Test3.fun(Test3.java:50)
	at com.example.demo.test.Test3.main(Test3.java:89)

                    

                            

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号