Java定时器的多线程

Question

我正在尝试编写一个简短的Java程序，它使用多个线程来创建计时器。当计时器达到7秒或15秒时，它将打印一条消息。

我需要创建一个共享计数器。时间打印线程将计数器递增1，并从执行开始每秒打印其值。一个消息打印线程每15秒打印一条消息，另一个消息打印线程每7秒打印一条不同的消息。这两个线程需要在不修改时间打印线程的情况下完成。

所有这些线程都需要共享每秒更新的计数器对象。每次更新计数器对象时，时间打印线程都会通知其他线程读取计数器对象。然后，每个消息打印线程将读取计数器值，并查看其指定的时间段是否已发生。

输出应该是这样的：

1 2 3 4 5 6
7 second message
7 8 9 10 11 12 13
7 second message
14
15 second message
15 16 17 18 19 20
7 second message
21 22 23 24  . . .

我需要通过为计时器创建一个线程，为7秒消息创建一个线程，为15秒消息创建一个线程来实现这一点。我在下面建立了这个：

import java.lang.Class;
import java.lang.Object;

class T1 extends Thread {
    private Main2 s;
    private int t;
    T1 (Main2 s) { this.s = s; }
    public void run()
    {
        while(true) {
            try { Thread.sleep(1000); }
            catch (InterruptedException e) { e.printStackTrace(); }
            s.setSharedTime (++t);
            System.out.print(t + " ");
        }
    }
}

class T2 extends Thread {
    private Main2 s;
    T2 (Main2 s) { this.s = s; }
    public void run()
    {
        while(true) { 
            int t = s.getSharedTime ();
            System.out.println();
            System.out.println ("7 second message");
        }
    }
}

class T3 extends Thread {
    private Main2 s;
    T3 (Main2 s) { this.s = s; }
    public void run()
    {
        while(true) { 
            int t = s.getSharedTime ();
            System.out.println();
            System.out.println ("15 second message");
        }
    }
}

public class Main2 {
    private int time;
    private boolean share = true;

    public static void main(String[] args) {
        Main2 s = new Main2();
        new T1 (s).start();
        new T2 (s).start();
        new T3 (s).start();
    }

    synchronized void setSharedTime (int s) {
        while (!share) {
            try { wait (); }
            catch (InterruptedException e) {}
        }
        this.time = s;
        if(s % 7 == 0)
            share = false;
        if(s % 15 == 0)
            share = false;
        notify ();
    }

    synchronized int getSharedTime () {
        while (share) {
            try { wait (); }
            catch (InterruptedException e) { }
        }
        share = true;
        notify ();
        return time;
    }
}

我遇到的问题是，我不能在正确的时间抛出7秒和15秒的消息。我如何将这三个线程一起运行，以组成一个工作计时器？

Answer 1

在代码中，您使用类T2和T3打印7秒和15秒的消息，但没有标识哪个消息是哪个消息，它们实际上是相同的，请保存打印的名称和字符串。调用notify（）时，没有指定锁的给定顺序。从notify（）的Javadocs：

被唤醒的线程将以通常的方式与任何其他线程竞争，这些线程可能会积极地在这个对象上进行同步

因此，无论哪个方法（T2的run（）或T3的run（））获得getSharedTime（）上的锁，都将继续并打印。查看这个问题和Javadocs以获取更多信息。

这是一种类似的方法来做同样的事情，我将检查时间是否是7或15的倍数移动到他们各自的类中，并以不同的方式构造了等待（）和通知（）。我还将打印与Timer类同步，以便同时（有效地）通知所有等待（）。在Timer类中处理每秒的打印时间，现在设置它的方式将给出您指定的输出，但是将setTime的打印和调用以及初始化时间切换到0将给出更准确的输出当前时间。

class Timer extends Thread{
    private int time = 1;
    private boolean setting = false;

    public void run(){
        while(true){
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.print(time + " ");
            setTime(time + 1);
            //Switching the order of these 2 ^^^ statements and initializing time to 0 will give an output that is more accurate to the time.
        }
    }
    public synchronized int getTime(){
        while(setting){
            try {
                wait(); //This will only be run on the off-chance that setTime is being run at the same time.
            } catch (InterruptedException e) {  }
        }

        return time;
    }
    public synchronized void setTime(int t){
        setting = true;
        this.time = t;
        setting = false;
        notifyAll();
    }
}

class Timer7 extends Thread{
    Timer timer;
    public Timer7(Timer t){
        this.timer = t;
    }

    public void run(){
        synchronized(timer){
            while(true){

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

                if(timer.getTime() % 7 == 0){
                    System.out.print("\n7 Second Message\n");
                }

            }
        }
    }
}

class Timer15 extends Thread{
    Timer timer;
    public Timer15(Timer t){
        this.timer = t;
    }

    public void run(){
        synchronized(timer){
            while(true){

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

                if(timer.getTime() % 15 == 0){
                    System.out.print("\n15 Second Message\n");
                }

            }
        }
    }
}

public class Main2 {

    public static synchronized void main(String[] args) {

        Timer timer = new Timer();
        timer.start();

        Timer7 t7 = new Timer7(timer);
        t7.start();

        Timer15 t15 = new Timer15(timer);
        t15.start();

    }

}