Java线程调度分离

程序的目标是将三个字符串发送到三个单独的线程，并让它们逐个字符地打印出每个字符串。我希望在每个输入字符串之间有一个空行，但我不确定应该将每个线程置于等待状态还是停止它，以使输出发生变化。大多数时候，它是一个杂乱的字符串组合，有时一个分开，整齐地出现

import java.util.Scanner;

public class Threader {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Hello");
        String str = scan.nextLine();
        String str2 = scan.nextLine();
        String str3 = scan.nextLine();

        Thread A = new Thread(new MyRunnable(str));
        A.start();

        Thread B = new Thread(new MyRunnable(str2));
        B.start();

        Thread C = new Thread(new MyRunnable(str3));
        C.start();
    }
}

public class MyRunnable implements Runnable {
    String str, str2, str3;
    public MyRunnable(String str){
        this.str = str;
    }

    @Override
    public void run() {
        for (int i = 0; i < str.length(); i++){
            System.out.println(str.charAt(i));
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }           
        }
    }
}

import java.util.Scanner；
公营螺纹机{
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
System.out.println（“你好”）；
String str=scan.nextLine（）；
字符串str2=scan.nextLine（）；
字符串str3=scan.nextLine（）；
线程A=新线程（新MyRunnable（str））；
A.开始（）；
线程B=新线程（新MyRunnable（str2））；
B.开始（）；
线程C=新线程（新MyRunnable（str3））；
C.开始（）；
}
}
公共类MyRunnable实现Runnable{
字符串str、str2、str3；
公共MyRunnable（字符串str）{
this.str=str；
}
@凌驾
公开募捐{
对于（int i=0；i

这个怎么样

import java.util.Scanner;

public class Threader {
    public Threader(String str, String str2, String str3) {
        Thread A = new Thread(new MyRunnable(str));
        Thread B = new Thread(new MyRunnable(str2));
        Thread C = new Thread(new MyRunnable(str3));

        A.start();
        B.start();
        C.start();
    }

    public synchronized void printString(String str) {
        for (Character c : str.toCharArray()) {
            System.out.println(c);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Hello");
        String str = scan.nextLine();
        String str2 = scan.nextLine();
        String str3 = scan.nextLine();

        new Threader(str, str2, str3);
    }

    class MyRunnable implements Runnable {
        private String str;

        public MyRunnable(String str) {
            this.str = str;
        }

        @Override
        public void run() {
            printString(str);
        }
    }
}

---

这是一个答案，拼写并用空格分隔每个字符串。有趣的是，我的老师只是想让他们同时开始并输出所有混乱的内容，只是为了演示一个比赛条件p但是在这里，一对夫妇在睡觉。虽然很难看，但很管用

import java.util.Scanner;

 public class Threader {

public static void main(String[] args) {

    Scanner scan = new Scanner(System.in);
    System.out.println("Enter 3 lines...Suuuuh dude");

    /*
     * Strangs
     */
    String str = scan.nextLine();
    String str2 = scan.nextLine();
    String str3 = scan.nextLine();

    /*
     * Intantiate threads holding runnable objects
     */
    Thread A = new Thread(new MyRunnable(str));
    Thread B = new Thread(new MyRunnable(str2));
    Thread C = new Thread(new MyRunnable(str3));

    A.start();
    // B.start();
    // C.start();

    /*
     * try { A.join(); B.join(); C.join();
     * 
     * } catch (InterruptedException e) { // TODO Auto-generated catch block
     * e.printStackTrace(); }
     */

    /*
     * Uncomment While() Loops To Eliminate race conditions (Threads will
     * sleep if previous one is Alive(Won't fight for cpu))
     */

    while (A.isAlive()) {
        try {

            B.sleep(1000);
            System.out.println("\n");
        } // end try
        catch (InterruptedException e) {
            e.printStackTrace();
        } // end catch
    } // end while

    B.start();
    while (B.isAlive()) {
        try {
            C.sleep(1000);
            System.out.println("\n");
        } // end try
        catch (InterruptedException e) {
            e.printStackTrace();
        } // end catch
    } // end while
    C.start();
}// main METHOD

}// Threader CLASS

//类w/Runnable Int

public class MyRunnable implements Runnable {

String str, str2, str3;

public MyRunnable(String str) {
    this.str = str;
    this.str2 = str2;
    this.str3 = str3;

}

@Override
public void run() {

    for (int i = 0; i < str.length(); i++) {
        System.out.println(str.charAt(i));
        try {
            // sleep 1 ms before printing next char
            Thread.sleep(1);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } // for
    System.out.println("end" + str);
}// run

}

公共类MyRunnable实现Runnable{
字符串str、str2、str3；
公共MyRunnable（字符串str）{
this.str=str；
this.str2=str2；
this.str3=str3；
}
@凌驾
公开募捐{
对于（int i=0；i

如果你想实现一个特定的分离，你肯定必须使用wait/notify或某种信号量。我不明白，你希望每个线程打印字符串，每行一个字符，但你不希望另一个线程打印，会有一个线程这样做吗？为什么否决？这段代码不符合OP的要求吗？