public class Strong {
    /**
     * 强引用 是最常见的引用， 首先用 new 关键字创建对象的时候
     * 这个对象就是一个强引用也就是默认的引用类型。 只要强引用的对象
     * 是可触及的， 那么他就不会被回收！如果强引用对象超过了他的作用范围
     * 或者被设置为 null  那就可以被回收了。
     *
     * 只要有强引用在， 当内存不足的时候jvm就算抛出OOM也不会回收掉它！
     */
    public static void main(String[] args) {
        String test_strong_reference = new String("test strong reference");
        String test = test_strong_reference;
        test_strong_reference = null;
        System.gc();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("test_strong_reference - > "+ test_strong_reference);
        System.out.println("test - > "+test);
    }
}

public class Soft {

    /**
     * 软引用， 用来描述那些还有用， 但是不是必须用的对象， 只被软引用关联着的对象
     * 在系统内存溢出之前，会把这些对象列进入回收范围之内进行二次回收， 如果回收之后
     * 内存还不够的话， 就抛出内存溢出的异常.
     * <p>
     * 可以在一些内存敏感的地方 进行使用, 高速缓存之类的
     * <p>
     * 内存够用的时候就保留软引用的可达对象
     * 内存不够的时候就回收可达对象
     *
     * @param args
     */
    public static void main(String[] args) {
        User cuiyt = new User(1, "cuiyt");
        SoftReference<User> reference = new SoftReference<User>(cuiyt);
        cuiyt = null;

        System.out.println(reference.get().toString());
        System.gc();
        System.out.println("after - > " + reference.get().toString());

        try {
            TimeUnit.SECONDS.sleep(3);
            byte[] bytes = new byte[1024 * 1024 * 7];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(reference.get());
        }
    }
}

public class Weak {
    /**
     * 弱引用， 发送GC就会被回收掉！ 不管内存够不够
     *
     * @param args
     */
    public static void main(String[] args) {

        WeakReference<User> test = new WeakReference<User>(new User(1, "@cuiyut"));
        System.out.println(test.get());
        System.gc();
        System.out.println(test.get());
    }
}

public class Empty {
    public static Empty empty;
    public static PhantomReference<Empty> reference;
    public static ReferenceQueue<Empty> queue;

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("调用 finalize");
        empty = this;
    }

    public static class Check extends Thread {
        @Override
        public void run() {
            while (true) {
                super.run();
                if (reference != null) {
                    PhantomReference<Empty> test = null;
                    try {
                        test = (PhantomReference<Empty>) queue.remove();
                    } catch (Exception e) {

                    }
                    if (test != null) {
                        System.out.println("跟踪垃圾回收过程， Empty 被GC");
                    }
                }
            }
        }
    }

    /**
     * 形同虚设的一个引用类型， 当试图从虚引用中获得对象的时候
     * 它总是空的 ！ 为一个对象设置虚引用关联的唯一目的是跟踪垃圾回收的过程
     * 比如: 能在这个对象被回收的时候发出一个通知
     */
    public static void main(String[] args) {
        Check check = new Check();
        check.setDaemon(true);
        check.start();

        queue = new ReferenceQueue<>();
        empty = new Empty();
        reference = new PhantomReference<>(empty, queue);
        // 取消强引用
        empty = null;
        System.out.println(reference.get());

        System.out.println("第一次GC");
        // 把回收的对象， 放到引用队列中
        System.gc();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("after 第一次GC");
        if (empty != null) {
            System.out.println("empty 可用");
        } else {
            System.out.println("empty 不可用");
        }
        System.out.println("第二次GC");

        // 取消强引用
        empty = null;
        System.gc();

        System.out.println("after 第二次GC");
        if (empty != null) {
            System.out.println("empty 可用");
        } else {
            System.out.println("empty 不可用");
        }
    }
}

import android.app.Activity;
import android.graphics.Rect;
import android.os.Build;
import android.view.View;
import android.widget.FrameLayout;

public class AndroidBug5497Workaround {
    public static void assistActivity(Activity activity) {
        new AndroidBug5497Workaround(activity);
    }

    private View mChildOfContent;
    private int usableHeightPrevious;
    private FrameLayout.LayoutParams frameLayoutParams;
    private int contentHeight;
    private boolean isfirst = true;
    private Activity activity;
    private int statusBarHeight;

    private AndroidBug5497Workaround(Activity activity) {
        //获取状态栏的高度
        int resourceId = activity.getResources().getIdentifier("status_bar_height", "dimen", "android");
        statusBarHeight = activity.getResources().getDimensionPixelSize(resourceId);
        this.activity = activity;
        FrameLayout content = (FrameLayout) activity.findViewById(android.R.id.content);
        mChildOfContent = content.getChildAt(0);

        //界面出现变动都会调用这个监听事件
        mChildOfContent.getViewTreeObserver().addOnGlobalLayoutListener(() -> {
            if (isfirst) {
                contentHeight = mChildOfContent.getHeight();//兼容华为等机型
                isfirst = false;
            }
            possiblyResizeChildOfContent();
        });

        frameLayoutParams = (FrameLayout.LayoutParams)
            mChildOfContent.getLayoutParams();
    }

    //重新调整跟布局的高度
    private void possiblyResizeChildOfContent() {

        int usableHeightNow = computeUsableHeight();

        //当前可见高度和上一次可见高度不一致 布局变动
        if (usableHeightNow != usableHeightPrevious) {
            //int usableHeightSansKeyboard2 = mChildOfContent.getHeight();//兼容华为等机型
            int usableHeightSansKeyboard = mChildOfContent.getRootView().getHeight();
            int heightDifference = usableHeightSansKeyboard - usableHeightNow;
            if (heightDifference > (usableHeightSansKeyboard / 4)) {
                // keyboard probably just became visible
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    //frameLayoutParams.height = usableHeightSansKeyboard - heightDifference;
                    frameLayoutParams.height = usableHeightSansKeyboard - heightDifference + statusBarHeight;
                } else {
                    frameLayoutParams.height = usableHeightSansKeyboard - heightDifference;
                }
            } else {
                frameLayoutParams.height = contentHeight;
            }

            mChildOfContent.requestLayout();
            usableHeightPrevious = usableHeightNow;
        }
    }

    /**
     * 计算mChildOfContent可见高度
     */
    private int computeUsableHeight() {
        Rect r = new Rect();
        mChildOfContent.getWindowVisibleDisplayFrame(r);
        return (r.bottom - r.top);
    }
}

// ...
setContentView(R.layout.xxx);
AndroidBug5497Workaround.assistActivity(this);
// ...

// 这里解释下这两个括号：
// 第一个括号创建了一个新的匿名内部类，相信这个大家都知道；
// 第二个括号声明了匿名内部类实例化时运行的实例初始化块。
removeProductsWithCodeIn(new HashSet<String>() {{
    add("XZ13s");
    add("AB21/X");
    add("YYLEX");
    add("AR5E");
 }});

final List<CompletableFuture<Void>> futureList = nameToContent.keySet().stream()
        .map(name -> CompletableFuture.runAsync(() -> doUploadFile(map, name, nameToContent), executor))
        .collect(Collectors.toList());

//noinspection ResultOfMethodCallIgnored
futureList.stream().map(CompletableFuture::join).collect(Collectors.toList());

// 注意：如果使用 count() 不会阻塞
// futureList.stream().map(CompletableFuture::join).count()

import cn.hutool.core.thread.ThreadUtil;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorOfWorkStealingPoolTest {
    public static void main(String[] args) {
        final ExecutorService executorService = Executors.newWorkStealingPool();
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            System.out.println(i);
            int finalI = i;
            executorService.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " - " + finalI);
                ThreadUtil.sleep(1000);
            });
        }
        ThreadUtil.sleep(1000000);
        executorService.shutdown();
    }
}