Moralok's Blog

private void scheduleRenewal() {
    String value = lockValue.get();
    ScheduledFuture<?> scheduledFuture = sScheduler.scheduleAtFixedRate(
        () -> this.renewal(value), RENEWAL_INTERVAL, RENEWAL_INTERVAL, TimeUnit.MILLISECONDS
    );
    renewalTask.set(scheduledFuture);
}

private ThreadLocal<Integer> lockCount = ThreadLocal.withInitial(() -> 0);

public boolean tryLock() {  
    Integer count = lockCount.get();  
    if (count != null && count > 0) {  
        lockCount.set(count + 1);   
        return true;    
    }  
    String result = commands.set(lockKey, lockValue.get(), SetArgs.Builder.nx().px(RedisLockManager.LOCK_EXPIRE));  
    if ("OK".equals(result)) {  
        lockCount.set(1);  
        scheduleRenewal();  
        return true;    
    }  
    return false;  
}

public class ByteCodeTest_2 {

    public static void main(String[] args) {
        int a = 10;
        int b = Short.MAX_VALUE + 1;
        int c = a + b;
        System.out.println(c);
    }
}

public class ByteCodeTest_3 {

    public static void main(String[] args) {
        int a = 10;
        int b = a++ + ++a + a--;
        System.out.println(a);
        System.out.println(b);
    }
}

public class ByteCodeTest_4 {

    public static void main(String[] args) {
        int a = 0;
        // ifeq, goto
        if (a == 0) {
            a = 10;
        } else {
            a = 20;
        }
    }
}

public class ReferenceTest_3 {
    private static final int _4MB = 4 * 1024 * 1024;

    // -Xmx20m -XX:+PrintGCDetails -verbose:gc
    public static void main(String[] args) throws IOException {
        // list -> WeakReference -> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> ref = new WeakReference<>(new byte[_4MB]);
            list.add(ref);
            System.out.print(list.size() + " ");
            for (WeakReference<byte[]> w : list) {

                System.out.print(w.get() + " ");
            }
            System.out.println();
        }
        System.out.println("循环结束： " + list.size());
        System.in.read();
    }
}

CARD_TABLE[this address >> 9] = 0;

public class StackTest_4 {

    private static int count = 0;

    // 改变栈的大小限制 -Xss256k，观察调用次数的变化
    public static void main(String[] args) {
        try {
            method1();
        } catch (Throwable t) {
            t.printStackTrace();
        } finally {
            // 默认情况下经过 20000+ 次，改变参数后 3000+ 次
            System.out.println(count);
        }
    }

    private static void method1() {
        count++;
        method1();
    }
}

public class StackTest_5 {

    public static void main(String[] args) throws JsonProcessingException {
        Department department = new Department();
        department.setName("Tech");

        Employee employee1 = new Employee();
        employee1.setName("Tom");
        employee1.setDepartment(department);

        Employee employee2 = new Employee();
        employee2.setName("Tim");
        employee2.setDepartment(department);

        department.setEmployees(Arrays.asList(employee1, employee2));

        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println(objectMapper.writeValueAsString(department));
    }

    static class Department {
        private String name;
        private List<Employee> employees;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public List<Employee> getEmployees() {
            return employees;
        }

        public void setEmployees(List<Employee> employees) {
            this.employees = employees;
        }
    }

    static class Employee {
        private String name;
        private Department department;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Department getDepartment() {
            return department;
        }

        public void setDepartment(Department department) {
            this.department = department;
        }
    }
}

public class StackTest_3 {

    public static void main(String[] args) {
        method1();
    }

    // 线程安全
    private static void method1() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb);
    }

    // 线程不安全
    private static void method2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb);
    }

    // 线程不安全，看到一个说法：发生指令重排，sb 的 append 操作发生在返回之后（有待确认）
    private static StringBuilder method3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
}

public class ThreadTest_1 {

    public static void main(String[] args) {
        new Thread(null, () -> {
            System.out.println("t1...");
            while (true) {

            }
        }, "thread1").start();

        new Thread(null, () -> {
            System.out.println("t2...");
            try {
                TimeUnit.SECONDS.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "thread2").start();

        new Thread(null, () -> {
            System.out.println("t3...");
            try {
                TimeUnit.SECONDS.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "thread3").start();
    }
}

public class ThreadTest_2 {

    private static final Object A = new Object();
    private static final Object B = new Object();

    public static void main(String[] args) {
        new Thread(null, () -> {
            System.out.println("t1...");
            synchronized (A) {
                System.out.println(Thread.currentThread().getName() + " get A");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (B) {
                    System.out.println(Thread.currentThread().getName() + " get B");
                }
            }
        }, "thread1").start();

        new Thread(null, () -> {
            System.out.println("t2...");
            synchronized (B) {
                System.out.println(Thread.currentThread().getName() + " get B");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (A) {
                    System.out.println(Thread.currentThread().getName() + " get A");
                }
            }
        }, "thread2").start();
    }
}

public class HeapTest_1 {  
  
    // -Xmx8m  
    // 不设置可能不提示 Java heap space，出错地方不同，报错信息不同  
    public static void main(String[] args) {  
        int i = 0;  
        try {  
            List<String> list = new ArrayList<>();  
            String s = "hello";  
            while (true) {  
                list.add(s);  
                s = s + s;  
                i++;  
            }  
        } catch (Throwable t) {  
            t.printStackTrace();  
        } finally {  
            System.out.println("运行次数 " + i);  
        }  
    }  
}

public class HeapTest_2 {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("1...");
        TimeUnit.SECONDS.sleep(30);
        // 堆空间占用上升 10MB
        byte[] bytes = new byte[1024 * 1024 * 10];
        System.out.println("2...");
        TimeUnit.SECONDS.sleep(30);
        bytes = null;
        // 堆空间占用下降
        System.gc();
        System.out.println("3...");
        TimeUnit.SECONDS.sleep(3000);
    }
}

public class HeapTest_3 {  
  
    // jps 查进程，jmap 看堆内存，jconsole 执行GC，堆内存占用没有明显下降  
    // 使用 VisualVM 的堆 dump 功能，观察大对象  
    public static void main(String[] args) throws IOException {  
        List<Student> students = new ArrayList<>();  
        for (int i = 0; i < 200; i++) {  
            students.add(new Student());  
        }  
        System.in.read();  
    }  
  
    static class Student {  
        private byte[] score = new byte[1024 * 1024];  
    }  
}

public class MethodAreaTest_1 extends ClassLoader {

    // -XX:MaxMetaspaceSize=8m MaxMetaspaceSize is too small.
    // -XX:MaxMetaspaceSize=10m java.lang.OutOfMemoryError: Compressed class space
    // 不是 Metaspace 应该是某个参数设置的问题
    // JDK 6: -XX:MaxPermSize=8m PermGen space
    public static void main(String[] args) {
        int j = 0;
        try {
            MethodAreaTest_1 methodAreaTest1 = new MethodAreaTest_1();
            for (int i = 0; i < 20000; i++, j++) {
                ClassWriter classWriter = new ClassWriter(0);
                // 版本号，public，类名，包名，父类，接口
                classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                // 返回二进制字节码
                byte[] code = classWriter.toByteArray();
                // 加载类
                methodAreaTest1.defineClass("Class" + i, code, 0, code.length);
            }
        } catch (ClassFormatError e) {
            e.printStackTrace();
        } finally {
            System.out.println("次数 " + j);
        }
    }
}

public class MethodAreaTest_2 {  
  
    public static void main(String[] args) {  
        System.out.println("hello world");  
    }  
}

public class DirectMemoryTest_1 {  
  
    private static final String FROM = "C:\\Users\\username\\Videos\\jellyfin\\media\\movies\\Harry Potter and the Chamber of Secrets (2002) [1080p]\\Harry.Potter.and.the.Chamber.of.Secrets.2002.1080p.BrRip.x264.YIFY.mp4";  
    private static final String TO = "C:\\Users\\username\\Videos\\jellyfin\\media\\movies\\Harry Potter and the Chamber of Secrets (2002) [1080p]\\Harry.Potter.and.the.Chamber.of.Secrets.2002.1080p.BrRip.x264.YIFY-copy.mp4";  
    private static final int _1Mb = 1024 * 1024;  
  
    public static void main(String[] args) {  
        io();  
        directBuffer();  
    }  
  
    private static void directBuffer() {  
        long start = System.nanoTime();  
        try (FileChannel from = new FileInputStream(FROM).getChannel();  
             FileChannel to = new FileOutputStream(TO).getChannel()) {  
            ByteBuffer buffer = ByteBuffer.allocateDirect(_1Mb);  
            while (true) {  
                int len = from.read(buffer);  
                if (len == -1) {  
                    break;  
                }  
                buffer.flip();  
                to.write(buffer);  
                buffer.clear();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        long end = System.nanoTime();  
        System.out.println("directBuffer 用时 " + (end - start) / 1000_000.0);  
    }  
  
    private static void io() {  
        long start = System.nanoTime();  
        try (FileInputStream from = new FileInputStream(FROM);  
             FileOutputStream to = new FileOutputStream(TO)) {  
            byte[] buffer = new byte[_1Mb];  
            while (true) {  
                int len = from.read(buffer);  
                if (len == -1) {  
                    break;  
                }  
                to.write(buffer);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        long end = System.nanoTime();  
        System.out.println("io 用时 " + (end - start) / 1000_000.0);  
    }  
}

public class DirectMemoryTest_2 {  
  
    private static final int _100Mb = 1024 * 1024 * 100;  
  
    public static void main(String[] args) {  
        List<ByteBuffer> list = new ArrayList<>();  
        int i = 0;  
        try {  
            while (true) {  
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);  
                list.add(byteBuffer);  
                i++;  
            }  
        } catch (Throwable t) {  
            t.printStackTrace();  
        } System.out.println(i);  
    }  
}

public class DirectMemoryTest_3 {

    private static final int _1GB = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1GB);
        System.out.println("分配完毕");
        System.in.read();
        System.out.println("开始释放");
        byteBuffer = null;
        // 随着 ByteBuffer 的释放，从任务管理器界面看到程序的内存的占用迅速下降 1GB。
        System.gc();
        System.in.read();
    }
}

public class DirectMemoryTest_4 {

    private static final int _1GB = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();

        // 分配内存
        long base = unsafe.allocateMemory(_1GB);
        unsafe.setMemory(base, _1GB, (byte) 0);
        System.in.read();

        // 释放内存
        unsafe.freeMemory(base);
        System.in.read();
    }

    private static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

DirectByteBuffer(int cap) {

    // 省略
    try {
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    // 省略
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    unsafe.freeMemory(address);
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

String s1 = "a";

public class StringTableTest_1 {  
    public static void main(String[] args) {  
        String s1 = "a";  
        String s2 = "b";  
        String s3 = "ab";  
    }
}

public class StringTableTest_8 {  
  
    // JDK 1.8 设置 -Xmx10m -XX:-UseGCOverheadLimit    
    // JDK 1.6 设置 -XX:MaxPerSize=10m
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
        int i = 0;  
        try {  
            for (int j = 0; j < 260000; j++) {  
                list.add(String.valueOf(j).intern());  
                i++;  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            System.out.println(i);  
        }  
    }  
}

public class StringTableTest_5 {  
  
    public static void main(String[] args) {  
        // "a"、"b" 作为字符串字面量，会解析得到字符串对象放入字符串常量池      
        // 但是 new String("a") 创建出来的字符串对象，不会进入字符串常量池        
        String s1 = new String("a") + new String("b");  
        // intern 方法尝试将 s1 放入 StringTable，无则放入，返回该对象引用，有则返回已存在对象的引用  
        String s2 = s1.intern();  
  
        String x = "ab";  
  
		System.out.println(s2 == x);  
		System.out.println(s1 == x); 
    }  
}

public class StringTableTest_6 {  
  
    public static void main(String[] args) {  
        // 将 "ab" 的赋值语句提前到最开始，"ab" 生成的字符串对象进入字符串常量池       
        String x = "ab";  
        String s1 = new String("a") + new String("b");  
        // intern 方法尝试将 s1 放入 StringTable，无则放入，返回该对象引用，有则返回已存在对象的引用  
        String s2 = s1.intern();  
  
        System.out.println(s2 == x);  
        System.out.println(s1 == x);  
    }  
}

public class StringTableTest_12 {

    public static void main(String[] args) throws IOException {
        new String("ab");
    }
}

public class StringTableTest_4 {  
  
    public static void main(String[] args) {  
        System.out.println();  
         
        System.out.println("1");  
        System.out.println("2");  
        System.out.println("3");  
        System.out.println("4");  
        System.out.println("5");  
        System.out.println("6");  
        System.out.println("7");  
        System.out.println("8");  
        System.out.println("9");  
        System.out.println("0");  
        System.out.println("1");  
        System.out.println("2");  
        System.out.println("3");  
        System.out.println("4");  
        System.out.println("5");  
        System.out.println("6");  
        System.out.println("7");  
        System.out.println("8");  
        System.out.println("9");  
        System.out.println("0");  
    }  
}

public class StringTableTest_9 {  
  
    // -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc  
    public static void main(String[] args) {  
        int i = 0;  
        try {  
            // 0->100->10000，观察统计信息中数量的变化以及垃圾回收记录
            for (int j = 0; j < 10000; j++) {  
                String.valueOf(j).intern();  
                i++;  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            System.out.println(i);  
        }  
    }  
}

public class StringTableTest_10 {  
  
    // -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics  
    // 默认->200000->1009(最小值)，观察耗时  
    public static void main(String[] args) {  
        try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("src/main/resources/linux.words"), StandardCharsets.UTF_8))) {  
            String line = null;  
            long start = System.nanoTime();  
            while (true) {  
                line = br.readLine();  
                if (line == null) {  
                    break;  
                }  
                line.intern();  
            }  
            System.out.println("cost: " + (System.nanoTime() - start) / 1000000) ;  
        } catch (IOException e) {  
            throw new RuntimeException(e);  
        }  
    }  
}

public class StringTableTest_11 {  
  
    // -Xms500m -Xmx500m -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics  
    public static void main(String[] args) throws IOException {  
        List<String> words = new ArrayList<>();  
        System.in.read();  
        for (int i = 0; i < 10; i++) {  
            try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("src/main/resources/linux.words"), StandardCharsets.UTF_8))) {  
                String line = null;  
                long start = System.nanoTime();  
                while (true) {  
                    line = br.readLine();  
                    if (line == null) {  
                        break;  
                    }    
                    // words.add(line);  
                    words.add(line.intern());  
                }  
                System.out.println("cost: " + (System.nanoTime() - start) / 1000000) ;  
            }  
        }  
        System.in.read();  
    }  
}

public class StringTableTest_2 {  
   
    public static void main(String[] args) {  
        String s1 = "a";  
        String s2 = "b";  
        String s3 = "ab";  
        String s4 = s1 + s2;  
    }  
}

public class StringTableTest_3 {

    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        String s5 = "a" + "b";
    }
}

public class JvmGcTest_1 {

    public static final int _512KB = 512 * 1024;
    public static final int _1MB = 1024 * 1024;
    public static final int _6MB = 6 * 1024 * 1024;
    public static final int _7MB = 7 * 1024 * 1024;
    public static final int _8MB = 8 * 1024 * 1024;

    // -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc
    // -XX:+UseSerialGC 避免幸存区比例动态调整
    public static void main(String[] args) {

    }
}

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    list.add(new byte[_7MB]);
}

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    list.add(new byte[_7MB]);
    list.add(new byte[_512KB]);
}

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    list.add(new byte[_7MB]);
    list.add(new byte[_512KB]);
    list.add(new byte[_512KB]);
}

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    list.add(new byte[_8MB]);
}

Heap
 def new generation   total 9216K, used 2177K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  26% used [0x00000000fec00000, 0x00000000fee20730, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
  to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
 tenured generation   total 10240K, used 8192K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  80% used [0x00000000ff600000, 0x00000000ffe00010, 0x00000000ffe00200, 0x0000000100000000)
 Metaspace       used 3353K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 360K, capacity 388K, committed 512K, reserved 1048576K

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    list.add(new byte[_8MB]);
    list.add(new byte[_8MB]);
}

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();

    new Thread(() -> {
        list.add(new byte[_8MB]);
        list.add(new byte[_8MB]);
    }).start();

    System.out.println("waiting...");
    try {
        System.in.read();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

public static void main(String[] args) {
    List<byte[]> list = new ArrayList<>();
    list.add(new byte[_8MB - 16]);
}

public Object getBean(String name) throws BeansException {
    // 具体工作由 doGetBean 完成
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(
    final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) 
    throws BeansException {
    // 转换名称：去除 FactoryBean 的前缀 &，将别名转换为规范名称
    final String beanName = transformedBeanName(name);
    Object bean;

    // 检查单例缓存中是否已存在
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // ...
        // 如果已存在，直接返回该实例或者使用该实例（FactoryBean）创建并返回对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        // 如果当前 Bean 是一个正在创建中的 prototype 类型，表明可能发生循环引用
        // 注意：Spring 并未解决 prototype 类型的循环引用问题，要抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        
        // 如果当前 beanFactory 没有 bean 定义，去 parent beanFactory 中查找
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        
        if (!typeCheckOnly) {
            // 标记为至少创建过一次
            markBeanAsCreated(beanName);
        }
        
        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 确保 bean 依赖的 bean（构造器参数） 都已实例化
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        // 注意：Spring 并未解决构造器方法中的循环引用问题，要抛异常
                    }
                    // 注册依赖关系，确保先销毁被依赖的 bean
                    registerDependentBean(dep, beanName);
                    // 递归，获取依赖的 bean
                    getBean(dep);
                }
            }
        }

        if (mbd.isSingleton()) {
            // 如果是单例类型（绝大多数都是此类型）
            // 再次从缓存中获取，如果仍不存在，则使用传入的 ObjectFactory 创建
            sharedInstance = getSingleton(beanName, new ObjectFactory<Object>(
                {
                    @Override
                    public Object getObject() throws BeansException {
                        try {
                            // 创建 bean
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            // 由于可能已经提前暴露，需要显示地销毁                
                            destroySingleton(beanName);
                            throw ex;
                        }
                    }
                });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
        else if (mbd.isPrototype()) {
            // 如果是原型类型，每次都新创建一个
            // ...
        }
        else {
            // 如果是其他 scope 类型
            // ...
        }
    }
    catch (BeansException ex) {
        cleanupAfterBeanCreationFailure(beanName);
        throw ex;
    }
}