if (children != null) {
            for (String v : children) {
                DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
                if (state == null) {
                    cycle.addLast(v);
                    List<String> ret = visitCycle(graph, graph.get(v), stateMap, cycle);
                    if (ret != null) {
                        return ret;
                    }

                if (phase != null) {
                    Deque<String> phases = getLifecycles(project);
                    if (!Objects.equals(phase, phases.peekLast())) {
                        phases.addLast(phase);
                        if ("clean".equals(phase)) {
                            cleanProjectLocalRepository(project);
                        }
                    }
                }
                break;

    @Override
    public void addFirst(E e) {
      synchronized (mutex) {
        delegate().addFirst(e);
      }
    }

    @Override
    public void addLast(E e) {
      synchronized (mutex) {
        delegate().addLast(e);
      }
    }

    @Override
    public boolean offerFirst(E e) {
      synchronized (mutex) {
        return delegate().offerFirst(e);
      }
    }

    public void testRemove() throws Exception {
        list.addLast(null);
        list.addLast("1");
        list.addLast("2");
        assertThat(list.remove("3"), is(not(true)));
        assertThat(list.remove("1"), is(true));
        assertThat(list.remove(null), is(true));
        list.clear();
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.remove(1);

      this.stack = new ArrayDeque<>();
      stack.addLast(expand(root));
    }

    @Override
    @CheckForNull
    protected T computeNext() {
      while (!stack.isEmpty()) {
        PostOrderNode<T> top = stack.getLast();
        if (top.childIterator.hasNext()) {
          T child = top.childIterator.next();
          stack.addLast(expand(child));
        } else {
          stack.removeLast();

        header.previous = header;
        for (int i = 0; i < size; i++) {
            addLast((E) s.readObject());
        }
    }

    @Override
    public Object clone() {
        final SLinkedList<E> copy = new SLinkedList<>();
        for (Entry e = header.next; e != header; e = e.next) {
            copy.addLast(e.element);
        }
        return copy;
    }

    /**
     * 配列に変換します。

        for (Vertex v : children) {
            DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
            if (state == null) {
                cycle.addLast(v.label);
                List<String> ret = visitCycle(v.children, stateMap, cycle);
                if (ret != null) {
                    return ret;
                }
                cycle.removeLast();

     *            破棄可能なリソース。{@literal null}であってはいけません
     */
    public static synchronized void add(final Disposable disposable) {
        assertArgumentNotNull("disposable", disposable);
        disposables.addLast(disposable);
    }

    /**
     * 破棄可能なリソースを先頭に登録します。
     * <p>
     * リソースは登録された逆順に破棄されるため、先頭に登録されたリソースは最後に破棄されることになります。
     * </p>
     *
     * @param disposable

        final TimeoutTask task = new TimeoutTask(timeoutTarget, timeout, permanent);
        timeoutTaskList.addLast(task);
        start();
        return task;
    }

    /**
     * 管理している {@link TimeoutTask}の数を返します。
     *
     * @return 管理している {@link TimeoutTask}の数
     */