Напишите программу, которая каждую секунду отображает на экране данные о времени, прошедшем от начала сессии, а другой ее поток выводит сообщение каждые 5 секунд. Предусмотрите возможность ежесекундного оповещения потока, воспроизводящего сообщение, потоком, отсчитывающим время. Не внося изменений в код потока-"хронометра" , добавьте еще один поток, который выводит на экран другое сообщение каждые 7 секунд.

class Event
{
    public boolean finish = false;
}

class notifier implements Runnable
{
    private Event event;
    private int delay = 1, elapsed = 0;
    notifier(){}
    notifier(int delay, Event event)
    {
        this.delay = delay;
        this.event = event;
    }
    public void run()
    {
        try
        {
            while(true)
            {
                synchronized(event) // *
                {
                    event.wait();
                }
                if(event.finish) return;
                ++elapsed;
                if(elapsed == delay)
                {
                    System.out.println(elapsed + " second(s) elapsed");
                    elapsed = 0;
                }
            }
        }
        catch(InterruptedException ex)
        {
        }
    }
}

public class Exercise
{
    private Event event = new Event();
    public static void main(String[] args)
    {
        System.out.println("START!");
        Exercise prog = new Exercise();
        prog.timer();
    }
    
    synchronized public void timer()
    {
        Runnable every_1 = new notifier(1, event);
        Runnable every_5 = new notifier(5, event);
        new Thread(every_1).start();
        new Thread(every_5).start();
        try
        {
            int i = 20;
            while(true)
            {
                Thread.sleep(1000);
                if(i-- < 0)
                {
                    event.finish = true;
                    synchronized(event)
                    {
                        event.notifyAll();
                    }
                    return;
                }
                synchronized(event)
                {
                    event.notifyAll();
                }
            }
        }
        catch(InterruptedException ex)
        {
        }
    }
}

• SWL: Exercise.timer() calls Thread.sleep() with a lock held
  This method calls Thread.sleep() with a lock held. This may result in very poor performance and scalability, or a deadlock, since other threads may be waiting to acquire the lock. It is a much better idea to call wait() on the lock, which releases the lock and allows other threads to run.
  

  А>    synchronized public void timer()
  А>    {
  А>        . . .
  А>            while(true)
  А>            {
  А>                Thread.sleep(1000);
  А>        . . .
  А>            }
  А>        . . .
  А>    }

  
  
  
• UW: Unconditional wait in notifier.run()
  This method contains a call to java.lang.Object.wait() which is not guarded by conditional control flow. If the condition that the method intends to wait for has already happened, the thread could wait indefinitely.
  

  А>                synchronized(event) // *
  А>                {
  А>                    event.wait();
  А>                }

synchronized(event) {
    event.wait();
}

synchronized(event) {
    event.notify();
}

synchronized (event) {
    if (!event.happened)
        event.wait();
}

synchronized (event) {
    event.happened = true;
    event.notify();
}

synchronized (event) {
    while (!event.happened)
        event.wait();
}

S>PS:

S>>Сейчас Spring пихают даже туда, где он не особо-то и нужен.
...
B>А без IoC можно и в 3х классах запутаться с инициализацией

public class CCC {

    public static void main(String[] args) throws IOException, InterruptedException {
        final MyTimer timer = new MyTimer();
        timer.start();

        Thread t1 = new Thread() {
            public void run() {
                TimeListener listener = new TimeListener() {
                    public int getFrequency() {
                        return 5;
                    }

                    public void onTimeout() {
                        System.out.println("#5: hello");
                    }
                };
                timer.addListener(listener);
                try {
                    Thread.currentThread().join();
                } catch (InterruptedException ignore) {
                }
            }
        };
        t1.setDaemon(true);
        t1.start();

        Thread t2 = new Thread() {
            public void run() {
                TimeListener listener = new TimeListener() {
                    public int getFrequency() {
                        return 7;
                    }

                    public void onTimeout() {
                        System.out.println("#7: hello");
                    }
                };
                timer.addListener(listener);
                try {
                    Thread.currentThread().join();
                } catch (InterruptedException ignore) {
                }
            }
        };
        t2.setDaemon(true);
        t2.start();

        Thread.currentThread().join();
    }
}

interface TimeListener {
    /** Means that onTimeout() should be invoked one time in returned period in seconds. */
    int getFrequency();
    void onTimeout();
}

class MyTimer {

    private static class DefaultTimeListener implements TimeListener {

        private long start;

        public int getFrequency() {
            return 1;
        }

        public void onTimeout() {
            System.out.println((System.currentTimeMillis() - start) + " milliseconds passed");
        }

        public void prepare() {
            start = System.currentTimeMillis();
        }
    }

    private final Map<TimeListener, Integer>/*<Listener, counter>*/ listeners = new HashMap<TimeListener, Integer>();
    private final DefaultTimeListener defaultTimeListener = new DefaultTimeListener();
    private volatile boolean keepRunning;
    private boolean started;

    public MyTimer() {
        addListener(defaultTimeListener);
    }

    public void start() {
        if (started) {
            throw new IllegalStateException("Timer is already started");
        }
        started = true;
        Thread thread = new Thread() {
            public void run() {
                System.out.println("timer started");
                defaultTimeListener.prepare();
                keepRunning = true;
                resetListeners();
                while(keepRunning) {
                    synchronized(listeners) {
                        for (TimeListener listener : listeners.keySet()) {
                            if (listener.getFrequency() <= listeners.get(listener)) {
                                try {
                                    listener.onTimeout();
                                } catch (Exception ignore) {
                                }
                                listeners.put(listener, 1);
                            } else {
                                listeners.put(listener, listeners.get(listener) + 1);
                            }
                        }
                    }
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        MyTimer.this.stop();
                    }
                }
                started = false;
                System.out.println("timer stopped");
            }
        };
        thread.setDaemon(true);
        thread.start();
    }

    public void stop() {
        keepRunning = false;
    }

    public void addListener(TimeListener listener) {
        if (null == listener) {
            throw new IllegalArgumentException("Can't process MyTimer.addListener() for "
                                                       + "the null listener reference.");
        }
        if (0 >= listener.getFrequency()) {
            throw new IllegalArgumentException("Can't process MyTimer.addListener() for the listener={"
                                               + listener + "}. Listeners frequency must be positive, "
                                               + "current is " + listener.getFrequency());
        }
        synchronized(listeners) {
            listeners.put(listener, 0);
        }
    }

    public void removeListener(TimeListener listener) {
        if (null == listener) {
            throw new IllegalArgumentException("Can't process MyTimer.removeListener() for "
                                                       + "the null listener reference.");
        }
        synchronized(listeners) {
            if (null == listeners.remove(listener)) {
                throw new IllegalArgumentException("Can't remove unregistered listener={" + listener + "}");
            }
        }
    }

    private void resetListeners() {
        synchronized(listeners) {
            for (TimeListener listener : listeners.keySet()) {
                listeners.put(listener, 0);
            }
        }
    }
}

try {
    listener.onTimeout();
} catch (Exception ignore) {
}

package ru.rsdn.tests;

public class ThreadsTest {

    public static void main(String[] littleReds) throws InterruptedException {
        Timer timer = new Timer(1000);
        Thread spamerThread = new Thread(new Spamer("Hello! You won lots of money!!!", 5, timer));
        Thread antiSpamerThread = new Thread(new Spamer("Hate spamers!", 7, timer));
        spamerThread.setDaemon(true);
        antiSpamerThread.setDaemon(true);
        timer.setDaemon(true);
        spamerThread.start();
        antiSpamerThread.start();
        timer.start();
        Thread.sleep(10000);
    }
}

class Timer extends Thread {
    private final long delta;

    public Timer(long millis) {
        delta = millis;
    }

    public void run() {
        long sessionStartTimeMillis = System.currentTimeMillis();
        long millisToSleep = delta;
        while (true) {
            long startSleeping = System.currentTimeMillis();
            try {
                Thread.sleep(millisToSleep);
            } catch (InterruptedException e) {
                System.out.println("Interrupted");
            }

            if (System.currentTimeMillis() - startSleeping < millisToSleep) {
                millisToSleep -= System.currentTimeMillis() - startSleeping;
            } else {
                millisToSleep = delta;
                System.out.println("Since session started (seconds):" + (System.currentTimeMillis() - sessionStartTimeMillis) / 1000);
                synchronized(this) {
                    this.notifyAll();
                }
            }
        }
    }
}

class Spamer implements Runnable {
    private final String adv;
    private final int maxCount;
    private final Object monitor;

    public Spamer(String spamMess, int numberOfNotification, Object monitor) {
        adv = spamMess;
        maxCount = numberOfNotification;
        this.monitor = monitor;
    }

    public void run() {
        int count = 0;
        while (true) {
            synchronized(monitor) {
                try {
                    monitor.wait();
                } catch (InterruptedException e) {
                    System.out.println("Interrupted");
                    continue;
                }
            }
            ++count;
            if (count == maxCount) {
                System.out.println(adv);
                count = 0;
            }
        }
    }
}

/**
 * Represents an object that is interested in timer service. An object should
 * provide timer with the information about interested frequency. Timer service
 * should notify the object with the specified frequency.
 */
interface TimeListener {
    /**
     * @return      interested frequency(1 time per returned number of seconds).
     */
    int getFrequency();

    /**
     * Is called by the timer service whith the specified frequency.
     */
    void onTimeout();
}

ГВ>try {
ГВ>    listener.onTimeout();
ГВ>} catch (Exception ignore) {
ГВ>}
ГВ>

public void onTimeout() {
    throw new RuntimeException("Just for fun");
}

B>public void onTimeout() {
B>    throw new RuntimeException("Just for fun");
B>}
B>

public void onTimeout() {
    throw new OutOfMemoryError();
}

public void onTimeout() {
    System.exit(0);
}

interface TimeListener {
    void onTimer() throws TimerException;
}