ARTS第六周

Algorithm

Permutations
Permutations II
排列组合，给定唯一整型数组，返回所有排列。
第一版代码，由于第二个问题唯一结果不能通过改第一版代码解决，看其他人解题思路更换代码

class Solution {
    public List> permute(int[] nums) {
        List list = new ArrayList<>();
        for(int i=0;i> result = new ArrayList<>();
        recurse(new ArrayList<>(), list, result);
        return result;
    }
    
    public void recurse(List list, List numList, List> result) {
        if (numList.size() == 0) {
            result.add(list);
        }
        for (Integer item : numList) {
            recurse(addMethod(list, item), subtractMethod(numList, item), result);
        }
    }
    
    public List addMethod(List list, Integer num) {
        List result = new ArrayList<>(list);
        result.add(num);
        return result;
    }
    
    public List subtractMethod(List list, Integer index) {
        List result = new ArrayList<>(list);
        result.remove(index);
        return result;
    }
}

第二版，关键逻辑就是排序之后，重复判断和使用标示判断

public List> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        List> result = new ArrayList<>();
        // 排序保证相同元素连续，nums元素唯一则不需要排序
        Arrays.sort(nums);
        recurse(new ArrayList<>(), nums, used ,result);
        return result;
    }

    public void recurse(List list, int[] nums, boolean[] used, List> result) {
        if (list.size() == nums.length) {
            result.add(new ArrayList<>(list));
        }
        int temp;
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;
            temp = nums[i];
            // nums元素唯一则不需要判断
            // 重复判断，i>0保证从第二个元素开始；
            // temp=nums[i - 1]保证连续2个相等，其中nums已经排序了；
            // !used[i - 1]保证上1个元素未用，如果使用了就是其中1个需要的结果（如，1、1、2，到第二个1时，第1个1已经使用是需要的结果）
            if (i > 0 && temp == nums[i - 1] && !used[i - 1]) continue;
            used[i] = true;
            list.add(temp);
            recurse(list, nums, used, result);
            list.remove(list.size() - 1);
            used[i] = false;
        }
    }

Review

java-garbage-collection-3
文中介绍了不同于G1到三种新的gc。

1. Epsilon（java11）
   只分配不回收，只到耗尽内存、崩溃。作用用来测试系统性能，使用无操作gc，系统客户忽略gc产生开销对系统造成的延迟和吞吐量较少的问题。
2. ZGC（java11）
   使用64位系统中一种指针着色技术，1个对象会占用更多空间记录额外信息。STW，检查GC roots和局部变量->并行阶段，遍历对象着色指针，标记对象->移动对象。
   ZGC会创建很多thread，可能导致应用饿死。
3. Shenandoah（java12）
   STW，为并发阶段准备heap对象和扫描GC roots->并发阶段遍历可达不可达对象->STW，完成标记、重新扫描root->并发阶段，最终标记的对象拷贝出去->STW，遍历对象跟新对象引用->STW，通过跟新root跟新引用，最后回收空间。
   相比于ZGC慢点，但是跟稳定，出现时间更长。甚至可以兼容java8

Tip

java线程异常需要重启，java线程中，java线程状态Thread.State中NEW、RUNNABLE、BLOCKED、BLOCKED、BLOCKED、TERMINATED，当线程结束或者异常后，thread处于TERMINATED状态是无法重新启动，需要重新new一个thread启动

##通过观察者实现线程重启
public class MyRunnable extends Observable implements Runnable {

    @Override
    public void run() {
        int i = 1;
        try {
            while (true) {
                doSomething(i);
                i++;
            }
        } catch (Exception ignore) {
        } finally {
            notifyOnEx();
        }
    }

    private void notifyOnEx() {
        super.setChanged();
        super.notifyObservers();
    }

    private void doSomething(int i) throws Exception {
        if(i == 10) throw new Exception("111");
        System.out.println("xxxx=" + i);
        Thread.sleep(1000);
    }

}

public class MyObserver implements Observer {

    private Runnable runnable;

    public MyObserver(Runnable runnable) {
        this.runnable = runnable;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("重启thread");
        new Thread(runnable).start();
    }
}

Share

实现异步转同步
java管程sychronized