Java 多线程延迟了整个程序并同时加载所有内容，需要一个合适的算法

这是我在桌上的卡片组代码，我以前从未使用过线程，也不知道如何使用。 我需要他们每个人都有2秒的延迟

最初，所有卡都是.setVisible（false）

---

这不是多线程问题

但是您可以通过将

卡

对象存储在

列表

中并对其进行迭代来实现这一点

List<Card> cardsList = new ArrayList<>();
cardsList.add(Card1);
...
cardsList.add(Card10);
try {
      for(Card card : cardsList) {
          card.setVisible(true);
          Thread.sleep(2000);
      }
} catch (InterruptedException ex) {
     Logger.getLogger(TableController.class.getName()).log(Level.SEVERE, null, ex);
} 

List cardsList=new ArrayList（）；
卡片列表添加（卡片1）；
...
卡片列表。添加（卡片10）；
试一试{
用于（卡片：卡片列表）{
设置为可见（真）；
《睡眠》（2000年）；
}
}捕获（中断异常例外）{
Logger.getLogger（TableController.class.getName（））.log（Level.SEVERE，null，ex）；
} 

您可以使用，这将处理多线程，并让操作在预定时间进行

long delay = 2000;
Timer timer = new Timer();
timer.schedule( new TimerTask(){
    @Override
    public void run(){
        Card1.setVisible(true); 
    }
}, delay);
timer.schedule( new TimerTask(){
    @Override
    public void run(){
        Card2.setVisible(true); 
    }
}, delay*2);

第一个任务将在延迟2000ms后运行，第二个任务将在延迟4000ms后运行。我停在那里是因为把所有的东西都写出来很麻烦。你应该考虑使用列表作为建议的其他答案。

---

顺便说一下，计时器将为您管理一个线程。我认为您的实际问题是您阻塞了

我们可以使用DelayQueue延迟打印结果

代码示例：

public static void main(String... args) throws InterruptedException {
        DelayQueue<DeleyedItem> dq = new DelayQueue();
        DeleyedItem ob1 = new DeleyedItem(TimeUnit.SECONDS.toMillis(2), Card1);
        DeleyedItem ob2 = new DeleyedItem(TimeUnit.SECONDS.toMillis(4), Card2);
        DeleyedItem ob3 = new DeleyedItem(TimeUnit.SECONDS.toMillis(6), Card3);

        dq.offer(ob1);
        dq.offer(ob2);
        dq.offer(ob3);

        while (!dq.isEmpty()) {
            DeleyedItem item = dq.take();
            item.visible();
        }

    }
}

class DeleyedItem implements Delayed {
    public final Long delayMillis;
    public final Long expireTimeMillis;
    private Card card;

    DeleyedItem(long delayMillis,Card card) {
        this.delayMillis = delayMillis;
        this.expireTimeMillis = System.currentTimeMillis() + delayMillis;
        this.card=card;
    }

    @Override
    public final int compareTo(Delayed o) {
        long diffMillis = getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        diffMillis = Math.min(diffMillis, 1);
        diffMillis = Math.max(diffMillis, -1);
        return (int) diffMillis;
    }

    @Override
    public final long getDelay(TimeUnit unit) {
        long delayMillis = expireTimeMillis - System.currentTimeMillis();
        return unit.convert(delayMillis, TimeUnit.MILLISECONDS);
    }

    public void visible() {
        card.setVisible(true);
    }

---

我在这里看不到任何多线程…根据您试图实现的，多线程将不会帮助您获得您想要的。因为这会弄乱订单。除非你想以混乱的模式展示这些卡片…那么会发生什么呢？为什么这不管用。我猜，18秒后，所有的卡突然被设置为可见。MCVE会很好，但我怀疑这里发生的是所有这些都发生在EDT线程上，这意味着在执行块之前不会重新绘制任何内容。这根本不能解决op的问题。这将是一种改进，但它也会遇到与op相同的问题。为什么您认为这比

Thread.sleep

？这仍然不能解决ops问题，因为他们正在“停车”EDT。它正在使用私有静态final sun.misc.Unsafe；//通过intrinsics API实现热点。可供所有并发API使用，优于Thread.sleep，Thread.sleep有其自身的局限性它无法解决问题，它也不能保证它会在规定的时间内“停车”。是的，你是对的，它会停车，但不能保证它会在规定的时间内停车。使用延迟队列，这样它会在延迟时间后返回，怎么样

public static void main(String... args) throws InterruptedException {
        DelayQueue<DeleyedItem> dq = new DelayQueue();
        DeleyedItem ob1 = new DeleyedItem(TimeUnit.SECONDS.toMillis(2), Card1);
        DeleyedItem ob2 = new DeleyedItem(TimeUnit.SECONDS.toMillis(4), Card2);
        DeleyedItem ob3 = new DeleyedItem(TimeUnit.SECONDS.toMillis(6), Card3);

        dq.offer(ob1);
        dq.offer(ob2);
        dq.offer(ob3);

        while (!dq.isEmpty()) {
            DeleyedItem item = dq.take();
            item.visible();
        }

    }
}

class DeleyedItem implements Delayed {
    public final Long delayMillis;
    public final Long expireTimeMillis;
    private Card card;

    DeleyedItem(long delayMillis,Card card) {
        this.delayMillis = delayMillis;
        this.expireTimeMillis = System.currentTimeMillis() + delayMillis;
        this.card=card;
    }

    @Override
    public final int compareTo(Delayed o) {
        long diffMillis = getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        diffMillis = Math.min(diffMillis, 1);
        diffMillis = Math.max(diffMillis, -1);
        return (int) diffMillis;
    }

    @Override
    public final long getDelay(TimeUnit unit) {
        long delayMillis = expireTimeMillis - System.currentTimeMillis();
        return unit.convert(delayMillis, TimeUnit.MILLISECONDS);
    }

    public void visible() {
        card.setVisible(true);
    }

public static void main(String[] args) {
        Card1.setVisible(true);

        await(2, TimeUnit.SECONDS);
        Card2.setVisible(true);
        await(4, TimeUnit.SECONDS);
        Card3.setVisible(true);
    }

    public static void await(long time, TimeUnit unit) {
        LockSupport.parkNanos(unit.toNanos(time));
    }