Question

我试图让两个线程同时工作。让我用代码解释一下：

运行两个线程的主类

public static void main(String[] args) {
    abThread.move(5);
    cdThread.move(5);
}

主题1：

static void move(int i) {
    int min = 0;
    int max = 100;

    while (i > 0) {
        int a = ThreadLocalRandom.current().nextInt(min, max + 1);
        //  try {
        //      Thread.sleep(100);
        //  } catch (Exception e) {
        //  }

        if ((a % 2) == 1) {
            System.out.println("a");
            i -= 1; 
            continue;
        } else {
            System.out.println("b");
            i -= 1; 
            continue;
        }
    }
}

主题2：

static void move(int i) {
    int min = 0;
    int max = 100;

    while (i > 0) {
        int a = ThreadLocalRandom.current().nextInt(min, max + 1);
        //  try {
        //      Thread.sleep(100);
        //  } catch (Exception e) {
        //  }

        if ((a % 2) == 1) {
            System.out.println("c");
            i -= 1; 
            continue;
        } else {
            System.out.println("d");
            i -= 1; 
            continue;
        }
    }
}

我随机a / b x 5，其中5个后随机（c / d）x5

我的目标是获得a / b，c / d，a / b，c / d ......等等

任何帮助或重定向到某种方式 - 都会非常感激！

编辑：注意我尝试了尝试睡眠，但它只是推迟了在a / b之后的下一个a / b之前多久。只有这样我才能做到a / b，c / b就是

    abThread.move(1);
    cdThread.move(1);
    abThread.move(1);

...

由于

Answer 1

由主线程以外的线程执行的工作由初始化的Runnable确定，或者如果您已覆盖它，则由其run()方法的实现确定。其中一个地方是您应该放置各种move()方法的调用。然后你的主线程应start()两个线程实例。

（可能）实现并行运行的线程，受线程调度和执行资源的可用性限制。然而，正如@Alexander描述的那样，它不一定能在两个线程的输出之间产生完美的交替，也不能保证一个线程产生的任何输出都会出现在另一个线程产生的任何输出之前。

如果您需要完美的交替，那么两个线程需要彼此同步才能轮流进行。您可以通过多种方式实现该方法，但如果您需要，则需要将其内置到move()方法中。低级的老派方式围绕着使用共享对象的wait()和notify() / notifyAll()方法。您还可以使用SynchronousQueue轮流两个线程，以及许多其他可能性。

Answer 2

如果你真的想尝试线程，不仅要交替打印字符，你可以尝试这样的事情：

首先，实现保存代码由线程运行的Runnable：

class Task implements Runnable {
    //c1 and c2 are characters to print (a,b and c,d for example)
    private final String c1, c2;
    //semaphore guarantees the order of threads execution
    private final Semaphore sync;
    private int i;

    Task(int i, String c1, String c2, Semaphore sync) {
        this.i = i;
        this.c1 = c1;
        this.c2 = c2;
        this.sync = sync;
    }
    @Override
    public void run() {
        try {
            int min = 0;
            int max = 100;
            while (i > 0) {
                sync.acquire();
                int a = ThreadLocalRandom.current().nextInt(min, max + 1);
                if ((a % 2) == 1) {
                    System.out.println(c1);
                    i -= 1;
                } else {
                    System.out.println(c2);
                    i -= 1;
                }
                sync.release();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

然后创建Semaphore：

Semaphore sync = new Semaphore(0, true);

创建两个线程并运行它们：

Thread t1 = new Thread(new Task(10, "a", "b", sync));
Thread t2 = new Thread(new Task(10, "c", "d", sync));

t1.start();
t2.start();

最后释放信号量，以便等待它的其中一个线程可以继续：

sync.release();

Answer 3

线程按照自己的节奏运行，按照操作系统的要求安排上下CPU。如果操作系统使用循环调度（即每个线程在一个圆圈中转弯），您只能期望执行a/b, c/d, a/b, c/d, ...，这几乎肯定不会。

同时运行两个线程（多线程？）

3 个答案: