Java 3个线程交替打印1到100

在多线程编程中,有一个常见的问题是如何使多个线程按照指定的顺序交替执行。在本文中,我们将通过一个具体的例子来讲解如何使用Java编程语言实现这个问题。

问题描述

我们需要编写一个程序,其中包含3个线程:ThreadA、ThreadB和ThreadC。ThreadA打印1到100之间的所有奇数,ThreadB打印1到100之间的所有偶数,ThreadC打印1到100之间的所有数字的平方。这些线程应该按照顺序依次打印这些数字,即首先打印ThreadA的数字,然后是ThreadB的数字,最后是ThreadC的数字。

解决方案

为了解决这个问题,我们可以使用Java中的wait()notifyAll()方法来实现线程的交替执行。首先,我们需要定义一个共享的对象,用于线程之间的通信。我们可以使用一个简单的整数变量作为共享对象,每个线程只能通过该对象来进行通信。

下面是示例代码:

public class AlternatePrinting {

    private static final Object lock = new Object();
    private static int number = 1;

    public static void main(String[] args) {

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        while (number <= 100) {
                            if (number % 2 != 0) {
                                System.out.println("ThreadA: " + number);
                                number++;
                                lock.notifyAll();
                            } else {
                                lock.wait();
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        while (number <= 100) {
                            if (number % 2 == 0) {
                                System.out.println("ThreadB: " + number);
                                number++;
                                lock.notifyAll();
                            } else {
                                lock.wait();
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        while (number <= 100) {
                            System.out.println("ThreadC: " + number * number);
                            number++;
                            lock.notifyAll();
                            lock.wait();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        threadA.start();
        threadB.start();
        threadC.start();
    }
}

在上面的代码中,我们使用了synchronized关键字来保证每个线程在访问共享对象时的互斥性。在每个线程中,我们使用了wait()方法来暂停线程的执行,直到其他线程通知它。notifyAll()方法用于唤醒正在等待的线程。

甘特图

下面是一个使用甘特图表示线程执行的示意图:

gantt
    dateFormat  YYYY-MM-DD
    section ThreadA
    ThreadA任务1 : active, 2022-10-01, 3d
    section ThreadB
    ThreadB任务1 : active, after ThreadA任务1, 3d
    section ThreadC
    ThreadC任务1 : active, after ThreadB任务1, 3d

在上面的甘特图中,我们可以看到ThreadA在ThreadB之前执行,ThreadB在ThreadC之前执行。

旅行图

下面是一个使用旅行图表示线程之间交替执行的示意图:

journey
    title 线程执行
    section 线程A
    线程A -> 线程B : 执行结束
    线程B -> 线程C : 执行结束
    线程C -> 线程A : 执行结束
    线程A -> 线程B : 执行结束
    线程B -> 线程C : 执行结束
    线程C -> 线程A : 执行结束
    ...

在上面的旅行图中,我们可以看到线程A、线程B和线程C按照指定的顺序依次执行,并且循