Добавить еще один поток, который выводит на экран другое сообщение каждые 7 секунд

public class test {
    public static void main (String [] args) throws InterruptedException{
        Chronometr my=new Chronometr();
        Runnable t1=new Messenger(5, my);
        new Thread(t1, "t1").start();
        for (int i=0;i<10;i++) {
            synchronized(my) {
                Thread.sleep(1000);
                Chronometr.time++;
                System.out.println(Chronometr.time);
                my.notifyAll();
                }
            }
        }
    }
    
class Chronometr {
    static int time=0;
    public void timeCount() throws InterruptedException {
         
    }
}   
class Messenger implements Runnable{
    int time;
    public Chronometr ch;
    Messenger(int time, Chronometr ch) {
        this.time=time;
        this.ch=ch;
    }
    public void waitForTime() {
        synchronized (ch) { 
            
            try{
                while (Chronometr.time%time!=0)
                    ch.wait();
                System.out.println("Thread "+this.time);
            }
            catch(InterruptedException e) {}
        } 
    }
    public void run() {
        waitForTime();
    }
}

    public static void main(String[] args) throws InterruptedException {
        Messenger m1 = new Messenger(1, 1);
        Messenger m5 = new Messenger(5, 2);
        Messenger m7 = new Messenger(7, 3);
        m1.run();
        m5.run();
        m7.run();
    }
 
    static class Messenger implements Runnable {
        int time;
        int id;
 
        /**
         * @param time time in seconds
         * @param id   id of thread
         */
        Messenger(int time, int id) {
            this.time = time * 1000;
            this.id = id;
        }
 
        @Override
        public void run() {
 
            Timer timer = new Timer();
            timer.schedule(new SayHello(id), 0, time);
        }
 
        class SayHello extends TimerTask {
            int id;
 
            SayHello(int id) {
                this.id = id;
            }
 
            @Override
            public void run() {
                System.out.printf("I'm thread with id=%d\n", id);
            }
        }
    }

public class test {
    public static void main (String [] args) throws InterruptedException{
        Chronometr my=new Chronometr();
        Runnable t1=new Messenger(5, my);
        
        new Thread(t1, "t1").start();
        
        for (int i=0;i<10;i++) {
            synchronized(my) {
                while (my.flag)
                    my.wait();
                Chronometr.time+=1;
                System.out.println(Chronometr.time);
    
                my.flag=false;
                my.notifyAll();
                
                
                }
            Thread.sleep(1000);
            }
        
        
        }
    }
    
class Chronometr {
    static int time=0;
    boolean flag=true;
    public void timeCount() throws InterruptedException {
         
    }
}   
class Messenger implements Runnable{
    int time;
    public Chronometr ch;
    Messenger(int time, Chronometr ch) {
        this.time=time;
        this.ch=ch;
    }
    public void waitForTime() {
        
        synchronized (ch) { 
            
            try{
            
            while (ch.flag) 
                ch.wait();
            
            if(Chronometr.time%this.time==0) 
            {
                System.out.println("Thread "+this.time);
                ch.flag=false;
                ch.notifyAll();
            }   
            ch.flag=false;
            ch.notifyAll();
            }
    
            catch(InterruptedException e) {}
        }
    } 
    
    public void run()  {
    waitForTime();
    }
}

    public void waitForTime() {
        Thread.currentThread().setDaemon(true);
        //...

public class test {
    public static void main (String [] args) throws InterruptedException{
        Chronometr my=new Chronometr();
        Runnable t1=new Messenger(5, my);
        Runnable t2=new Messenger(1, my);
        new Thread(t1, "t1").start();
        new Thread(t2, "t2").start();
        my.countTime((Messenger)t1, (Messenger)t2, 10);
        }
    }
    
 
class Chronometr {
public int time=0;
public void countTime (Messenger m, Messenger m1, int period) {
    for (int i=0; i<period; i++){
        synchronized(this) {
            time+=1;
            System.out.println(time);
            if (i==period-1) Messenger.finish=true;
            m.flag=false;
            this.notify();
            m1.flag=false;
            this.notify();
            }
    try {   Thread.sleep(1000);}
    catch (InterruptedException e) {};
        }
}
}   
class Messenger implements Runnable{
    private int time;
    public Chronometr ch;
    public static boolean finish=false;
    public boolean flag=true;
    Messenger(int time, Chronometr ch) {
        this.time=time;
        this.ch=ch;
    }
    public void waitForTime() {
        while(true){
        synchronized (ch) { 
            try{
                while (flag) 
                    ch.wait();
                if (finish) return;
                if(ch.time%this.time==0) 
                {
                    System.out.println("Thread "+this.time);
                    flag=true;
                }   
                flag=true;
            }
            catch(InterruptedException e) {}
        }}
    } 
    public void run()  {
        waitForTime();
        System.out.println("The end");
        }
}

public void waitForTime() { 
while(true){
        synchronized (ch) { 
            try{
                if (ch.time%this.time==0) 
                    System.out.println("Thread "+this.time);
                    ch.wait();
                if (finish) return;
                }
            catch (InterruptedException e) {}
            
        }}