• Home
• io.github.shanqiang-sq
• jstream
• 2.0.6
• source code
• InternalUnsafe.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.github.shanqiang.offheap.InternalUnsafe Maven / Gradle / Ivy

package io.github.shanqiang.offheap;

import io.github.shanqiang.SystemProperty;
import io.github.shanqiang.Threads;
import com.google.common.base.StandardSystemProperty;
import io.airlift.units.DataSize;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import oshi.SystemInfo;
import oshi.hardware.GlobalMemory;
import sun.misc.Unsafe;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.management.ManagementFactory;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.TreeMap;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

import static io.airlift.units.DataSize.Unit.GIGABYTE;
import static java.lang.String.format;
import static sun.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET;

public class InternalUnsafe {
    private static final Logger logger = LoggerFactory.getLogger(InternalUnsafe.class);
    private static final Object INTERNAL_UNSAFE;
    private static final Method ALLOCATE_ARRAY_METHOD;
    private static final Boolean UNALIGNED;
    private static final Unsafe unsafe;
    private static final int pageSize;
    private static final AtomicLong usedMemory = new AtomicLong();
    private static volatile long maxDirectMemory;
    private static volatile AtomicLong reservedMemory;
    private static final TreeMap addr2length = new TreeMap<>();
    private static volatile long lastOutOfMemoryMillis = 0L;
    private static final GlobalMemory globalMemory = new SystemInfo().getHardware().getMemory();
    private static final long totalPhysicalMemory = globalMemory.getTotal();

    static {
        try {
            String maxMemory = "maxMemory";
            String reservedMemoryName = "reservedMemory";
            String javaVersion = StandardSystemProperty.JAVA_VERSION.value();
            if ("11".compareTo(javaVersion) <= 0) {
                maxMemory = "MAX_MEMORY";
                reservedMemoryName = "RESERVED_MEMORY";
            }
            Class clazz = Class.forName("java.nio.Bits");
            Field field = clazz.getDeclaredField(maxMemory);
            field.setAccessible(true);
            maxDirectMemory = field.getLong(null);

            field = clazz.getDeclaredField(reservedMemoryName);
            field.setAccessible(true);
            reservedMemory = (AtomicLong) field.get(null);

            new ScheduledThreadPoolExecutor(1, Threads.threadsNamed("active-gc")).scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    try {
                        long availPhysicalMemory = globalMemory.getAvailable();
                        //可用内存不足20%更新最大内存为当前已使用内存量强制释放10%内存出来（参见NsdbPagesStore.expirePages）
                        //一段时间后maxDirectMemory将定格在物理内存的80%
                        if (availPhysicalMemory < totalPhysicalMemory * 2 / 10) {
                            if (getUsedMemory() + directMemoryUsed() < maxDirectMemory) {
//                                maxDirectMemory = getUsedMemory() + directMemoryUsed();
                            }
                        }
                        logger.info("maxDirectMemory: " + DataSize.ofBytes(maxDirectMemory()).to(GIGABYTE) +
                                ", usedMemory: " + DataSize.ofBytes(getUsedMemory()).to(GIGABYTE) +
                                ", bufferOffheap: " + DataSize.ofBytes(BufferOffheap.bufferOffheapSize()).to(GIGABYTE) +
                                ", directMemoryUsed: " + DataSize.ofBytes(directMemoryUsed()).to(GIGABYTE) +
                                ", totalPhysicalMemory: " + DataSize.ofBytes(totalPhysicalMemory).to(GIGABYTE) +
                                ", availPhysicalMemory: " + DataSize.ofBytes(availPhysicalMemory).to(GIGABYTE));
                        tryFullGC();
                    } catch (Throwable t) {
                        logger.error("", t);
                    }
                }
            }, 5, 5, TimeUnit.SECONDS);
        } catch (IllegalAccessException e) {
            logger.error("", e);
        } catch (NoSuchFieldException e) {
            logger.error("", e);
        } catch (ClassNotFoundException e) {
            logger.error("", e);
        }
    }

    private static RuntimeException handleInaccessibleObjectException(RuntimeException e) {
        if ("java.lang.reflect.InaccessibleObjectException".equals(e.getClass().getName())) {
            return e;
        }
        throw e;
    }

    private static Throwable trySetAccessible(AccessibleObject object, boolean checkAccessible) {
        if (checkAccessible) {
            return new UnsupportedOperationException("Reflective setAccessible(true) disabled");
        }
        try {
            object.setAccessible(true);
            return null;
        } catch (SecurityException e) {
            return e;
        } catch (RuntimeException e) {
            return handleInaccessibleObjectException(e);
        }
    }

    private static ClassLoader getSystemClassLoader() {
        if (System.getSecurityManager() == null) {
            return ClassLoader.getSystemClassLoader();
        } else {
            return AccessController.doPrivileged(new PrivilegedAction() {
                @Override
                public ClassLoader run() {
                    return ClassLoader.getSystemClassLoader();
                }
            });
        }
    }

    private static ClassLoader getClassLoader(final Class clazz) {
        if (System.getSecurityManager() == null) {
            return clazz.getClassLoader();
        } else {
            return AccessController.doPrivileged(new PrivilegedAction() {
                @Override
                public ClassLoader run() {
                    return clazz.getClassLoader();
                }
            });
        }
    }

    static {
        // attempt to access field Unsafe#theUnsafe
        final Object maybeUnsafe = AccessController.doPrivileged(new PrivilegedAction