如何使用多线程按顺序打印数字

Question

我想用像t1、t2、t3、t4、t2、t3、t3、t

public class NumberGame {
    static int a=1;
    public static void main(String args[]) throws InterruptedException
    {
        PrintSequenceRunnable C1=new PrintSequenceRunnable("T1",a);
        PrintSequenceRunnable C2=new PrintSequenceRunnable("T2",a);
        PrintSequenceRunnable C3=new PrintSequenceRunnable("T3",a);

        Thread t1 = new Thread(C1);

        Thread t2 = new Thread(C2);

        Thread t3 = new Thread(C3);


        t1.start();

        t2.start();

        t3.start(); 

    }
}



public class PrintSequenceRunnable implements Runnable {
    String tname;
    int a;

    PrintSequenceRunnable(String tname, int a )
    {
        this.tname = tname;
        this.a = a;

    }

    @Override
    public void run() {

        synchronized (this) {
            for(int i=0; i<10;i++)
            {
                System.out.println(tname+" "+a);
                a++;
                try {
                    this.wait(1000);
                    this.notify();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }

        // TODO Auto-generated method stub

    }

}

但我的输出就像

T1-1 T2-1 T3-1 T1-2 T3-2 T3-2 t3 t4 t5 t5 t6 t7 t8 t3 t9 t1 t1 10 t3

有人能帮我吗。

Answer 1

仅仅为了学习，这就是执行顺序输出的方法。但是请注意，线程的顺序执行并不能以任何方式得到保证。正如其他人指出的那样，这个问题不是多线程的好选择。如果你想按顺序做某事，那就用一个线程来做。

public class NumberGame {
    public static void main(String[] args) {

        PrintSequenceRunnable.startFrom("T1");

        new Thread(new PrintSequenceRunnable("T1", "T2")).start();
        new Thread(new PrintSequenceRunnable("T2", "T3")).start();
        new Thread(new PrintSequenceRunnable("T3", "T1")).start();
    }
}

class PrintSequenceRunnable implements Runnable {

    private final String name;
    private final String next;

    private static String moveTo;

    private static int value = 1;

    PrintSequenceRunnable(String name, String next) {
        this.name = name;
        this.next = next;
    }

    static void startFrom(String start) {
        moveTo = start;
    }

    private int uselessCounter = 0;

    @Override
    public void run() {
        do {
            synchronized (moveTo) {
                if (name.equals(moveTo)) {
                    System.out.println(name + "-" + (value++));
                    moveTo = next;
                } else {
                    uselessCounter++;
                }
            }
        } while (value < 10);
        System.out.println("Ran " + name + " uselessly for " + uselessCounter + " times."); // remove it.
    }

}

Answer 2

问题是：

1. 设计在线程之间存在引发条件的问题，您需要同步它们。
2. 在使用构造函数PrintSequenceRunnable(String tname, int a )时，您将发送原语变量a的副本，这是一个静态成员NumberGame。因此，每个PrintSequenceRunnable都有自己的变量a。

我的建议是使用methos、wait和notify同步每个线程。我给你取了代码并做了一些修改：

NumberGame

public class NumberGame {

    public static void main(String args[]) throws InterruptedException
    {       
        PrintSequenceRunnable C1=new PrintSequenceRunnable("T1");
        PrintSequenceRunnable C2=new PrintSequenceRunnable("T2");
        PrintSequenceRunnable C3=new PrintSequenceRunnable("T3");

        Thread t1 = new Thread(C1);
        Thread t2 = new Thread(C2);
        Thread t3 = new Thread(C3);

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

        Thread.sleep(1);//Wait 1 ms to avoid a raise condition

        PrintSequenceRunnable.activateNextItem(); //Start sequence.


        t1.join();
        t2.join();
        t3.join();

        System.out.println("--END--");
    }
}

PrintSequenceRunnable

import java.util.Vector;

public class PrintSequenceRunnable implements Runnable {    

    static private int a = 0;
    private static Vector<PrintSequenceRunnable> items = new Vector<PrintSequenceRunnable>();

    /**
     * Method to select the next Thread which will be activate to continue its thread.
     */
    public static synchronized void activateNextItem() {
        int index = a % items.size();
        items.get(index).activate();
    }

    private String tname;
    private Object sempahoro = new Object(); //Object to sinchrony the  thread

    public PrintSequenceRunnable(String tname)
    {
        this.tname = tname;
        items.add(this);
    }

    public void activate()
    {
        synchronized (sempahoro) {
            sempahoro.notify();
        }
    }

    @Override
    public void run() {
        for(int i=0; i<10;i++)
        {

            synchronized (sempahoro) {
                try {
                    sempahoro.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            a++;
            System.out.println(tname+" "+a);            
            activateNextItem(); //Raise the next thread.
        }
        // TODO Auto-generated method stub
    }
}

在此示例中，方法activateNextItem, fromPrintSequenceRunnable`将决定将通知哪个实例穿透其线程。

重要的是，我需要在init每个线程之后设置一个1秒的sleep，以避免引发条件，我的意思是:等待所有线程启动，并使所有线程处于等待状态。

产出：

T1 1
T2 2
T3 3
T1 4
T2 5
T3 6
T1 7
T2 8
T3 9
T1 10
T2 11
T3 12
T1 13
T2 14
T3 15
T1 16
T2 17
T3 18
T1 19
T2 20
T3 21
T1 22
T2 23
T3 24
T1 25
T2 26
T3 27
T1 28
T2 29
T3 30
--END--