Algorithm
Permutations
Permutations II
排列组合，给定唯一整型数组，返回所有排列。
第一版代码，由于第二个问题唯一结果不能通过改第一版代码解决，看其他人解题思路更换代码
class Solution {
public List<List<Integer>> permute(int[] nums) {
List<Integer> list = new ArrayList<>();
for(int i=0;i<nums.length;i++) {
list.add(nums[i]);
}
List<List<Integer>> result = new ArrayList<>();
recurse(new ArrayList<>(), list, result);
return result;
}
public void recurse(List<Integer> list, List<Integer> numList, List<List<Integer>> result) {
if (numList.size() == 0) {
result.add(list);
}
for (Integer item : numList) {
recurse(addMethod(list, item), subtractMethod(numList, item), result);
}
}
public List<Integer> addMethod(List<Integer> list, Integer num) {
List<Integer> result = new ArrayList<>(list);
result.add(num);
return result;
}
public List<Integer> subtractMethod(List<Integer> list, Integer index) {
List<Integer> result = new ArrayList<>(list);
result.remove(index);
return result;
}
}
第二版，关键逻辑就是排序之后，重复判断和使用标示判断
public List<List<Integer>> permuteUnique(int[] nums) {
boolean[] used = new boolean[nums.length];
List<List<Integer>> result = new ArrayList<>();
// 排序保证相同元素连续，nums元素唯一则不需要排序
Arrays.sort(nums);
recurse(new ArrayList<>(), nums, used ,result);
return result;
}
public void recurse(List<Integer> list, int[] nums, boolean[] used, List<List<Integer>> 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。
- Epsilon（java11）
只分配不回收，只到耗尽内存、崩溃。作用用来测试系统性能，使用无操作gc，系统客户忽略gc产生开销对系统造成的延迟和吞吐量较少的问题。 - ZGC（java11）
使用64位系统中一种指针着色技术，1个对象会占用更多空间记录额外信息。STW，检查GC roots和局部变量->并行阶段，遍历对象着色指针，标记对象->移动对象。
ZGC会创建很多thread，可能导致应用饿死。 - 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();
}
}
