Java 如何根据输出来自的线程创建单独的输出行？

我有一个实现两种不同排序算法的程序。我通过在单独的线程中启动这两个算法来并行测试它们。我希望能够查看排序操作的结果，因为它们发生在每个线程中，并且我尝试将这些结果保持在同一行（对于每个线程）

例如：

Arr1=3 5 8 11 16。。。（对线程1的输出进行排序）
Arr2=47991017。。。（对线程2的输出进行排序）

在主逻辑运行之后，我已经用

Thread.sleep（xxx）

实现了这一点，但这只在我只有一个线程时起作用。如果我将此延迟放在两个线程中，它会显示如下内容：

Arr1=
Arr2=Arr1[i]Arr2[i]Arr1[i+1]Arr2[i+2]

换句话说，两种排序的输出显示在同一行上

这是我的密码：

import java.util.PriorityQueue;

class sortareBubbleSort extends Thread {
    int nre, min, max;

    public sortareBubbleSort(int nre, int min, int max) {
        this.nre = nre;
        this.min = min;
        this.max = max;
    }

    public void run() {
        int[] x = new int[nre];
        for (int i = 0; i < x.length - 1; i++)
            x[i] = min + (int) (Math.random() * ((max - min) + 1));
        boolean doMore = true;
        while (doMore) {
            doMore = false;
            for (int i = 0; i < x.length - 1; i++) {
                if (x[i] > x[i + 1]) {
                    int temp = x[i];
                    x[i] = x[i + 1];
                    x[i + 1] = temp;
                    doMore = true;

                }
            }
        }

        System.out.println("\nHere is the sorted array with BubbleSort:");
        for (int i = 0; i < x.length; i++)
            System.out.print(x[i] + " ");
        System.out.print("\n");

    }
}

class sortareHeapSort extends Thread {
    int nre, min, max;

    public sortareHeapSort(int nre, int min, int max) {
        this.nre = nre;
        this.min = min;
        this.max = max;
    }

    public void run() {
        int[] x = new int[nre];
        for (int i = 0; i < x.length - 1; i++)
            x[i] = min + (int) (Math.random() * ((max - min) + 1));

        PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();
        for (int w : x)
            pQueue.add(w);
        for (int k = 0; k < x.length; k++)
            x[k] = pQueue.poll();

        // Print the array
        System.out.println("\nHere is the sorted array with HeapSort:");
        for (int w : x)
            System.out.print(w + "  ");
    }
}

public class TestThread {
    public static void main(String args[]) {
        sortareBubbleSort fir1;
        sortareHeapSort fir2;
        fir1 = new sortareBubbleSort(10, 1, 100);
        fir2 = new sortareHeapSort(10, 100, 200);
        fir1.start();
        fir2.start();
    }
}

import java.util.PriorityQueue；
类sortareBubbleSort扩展了线程{
整数nre，最小值，最大值；
公共sortareBubbleSort（int-nre、int-min、int-max）{
this.nre=nre；
this.min=min；
this.max=max；
}
公开募捐{
int[]x=新的int[nre]；
对于（int i=0；ix[i+1]）{
int temp=x[i]；
x[i]=x[i+1]；
x[i+1]=温度；
多莫尔=真；
}
}
}
System.out.println（“\n HERE是带BubbleSort:”的排序数组）；
对于（int i=0；i

---

非常感谢您的帮助或指导。

尝试创建一个同步静态方法来打印数组，这样第一个完成其工作的线程就可以获得锁，并且只有在打印整个数组时才释放锁。

为什么不以单独的列而不是行打印：

Bubblesort    Heapsort
3             
              4
5             
8
              7
11             
              9
16
              10
              17

---

这将更容易实现，只需将每个结果打印在新行上，并根据排序算法调整缩进。

@Mr.Cool我认为，他的意思是其他。将整个输出构建为一个字符串，并使用一些记录器（例如带有Logback的Slf4J）不幸的是，你对典型的控制台设备没有那种程度的控制。您必须实现自己的“输出”控制台，该控制台可以识别线程源，并且可以将它们各自的输出分离到专用的“行”。我质疑这样做的重要性，以及实施它所需的努力。