Java 死锁：找出谁在等谁，再统一拿锁顺序

import java.util.*;

public class Main {
    static final class Frame { final int node; int next; Frame(int node){this.node=node;} }
    static List<Integer> cycle(int n,int[][] edges) {
        if(n<0) throw new IllegalArgumentException();
        Objects.requireNonNull(edges);
        List<List<Integer>> graph=new ArrayList<>();
        for(int i=0;i<n;i++) graph.add(new ArrayList<>());
        for(int[] edge:edges) {
            if(edge==null || edge.length!=2 || edge[0]<0 || edge[0]>=n || edge[1]<0 || edge[1]>=n)
                throw new IllegalArgumentException("edge");
            graph.get(edge[0]).add(edge[1]);
        }
        int[] color=new int[n],parent=new int[n]; Arrays.fill(parent,-1);
        Deque<Frame> stack=new ArrayDeque<>();
        for(int root=0;root<n;root++) if(color[root]==0) {
            color[root]=1; stack.push(new Frame(root));
            while(!stack.isEmpty()) {
                Frame frame=stack.peek();
                if(frame.next==graph.get(frame.node).size()) {
                    color[frame.node]=2; stack.pop(); continue; // 所有出边处理完才标为完成。
                }
                int to=graph.get(frame.node).get(frame.next++);
                if(color[to]==0) {
                    parent[to]=frame.node; color[to]=1; stack.push(new Frame(to));
                } else if(color[to]==1) { // 回到当前路径中的祖先，找到真正有向环。
                    List<Integer> path=new ArrayList<>();
                    int at=frame.node; path.add(at);
                    while(at!=to) { at=parent[at]; path.add(at); }
                    Collections.reverse(path); path.add(to); // 补上终点形成闭合证据路径。
                    return List.copyOf(path);
                }
            }
        }
        return List.of();
    }
    static void check(boolean ok) { if(!ok) throw new AssertionError(); }
    public static void main(String[] args) {
        check(cycle(3,new int[][]{{0,1},{1,2},{2,0}}).equals(List.of(0,1,2,0)));
        check(cycle(3,new int[][]{{0,1},{1,2}}).isEmpty());
        check(cycle(1,new int[][]{{0,0}}).equals(List.of(0,0)));
        check(cycle(4,new int[][]{{0,1},{2,3},{3,2}}).equals(List.of(2,3,2)));
        check(cycle(3,new int[][]{{0,1},{0,1},{0,2},{2,1}}).isEmpty());
        check(cycle(0,new int[0][]).isEmpty());
        int n=20000; int[][] chain=new int[n-1][2];
        for(int i=0;i<n-1;i++) {chain[i][0]=i;chain[i][1]=i+1;}
        check(cycle(n,chain).isEmpty());
        System.out.println("PASS 7");
    }
}