Search code examples
multithreadingsleepwaitnotify

Digital Clock with multithreading with only sleep, wait and notify


could you please check the below code, which is digital clock without util.concurrent package, Calendar by using the sleep, notify, wait. the code is executing correctly please suggest any better way. Thanks alot

/**
 * 
 */
package com.nagihome.clock;

/**
 * @author Nagi
 * 
 */
public class ThreadAlarmClock {

    private static Integer hours = 23;
    private static Integer minutes = 59;
    private static Integer seconds = 55;
    private static Integer minSecLastNum = 60;
    private static Integer hour24LastNum = 24;
    private static String COLON = ":";
    private static Boolean isMinUpdatable = false;
    private static Boolean isHourUpdatable = false;
    final static Object lock = new Object();

    public void updateSeconds() throws InterruptedException {

        synchronized (lock) {
            while (true) {
                if (isMinUpdatable || isHourUpdatable) {
                    lock.wait();
                } else {
                    Thread.sleep(1000);
                    seconds++;
                    if (seconds.equals(minSecLastNum)) {
                        seconds = 0;
                        isMinUpdatable = true;
                        lock.notifyAll();
                    } else {
                        displayTime();
                    }
                }
            }
        }
    }

    public void updateMinutes() throws InterruptedException {

        synchronized (lock) {
            while (true) {
                if (!isMinUpdatable) {
                    lock.wait();
                } else if (isMinUpdatable) {
                    minutes++;
                    isMinUpdatable = false;
                    if (minutes.equals(minSecLastNum)) {
                        minutes = 0;
                        isHourUpdatable = true;
                    } else {
                        displayTime();
                    }
                }

                lock.notifyAll();
            }
        }
    }

    public void updateHours() throws InterruptedException {

        synchronized (lock) {
            while (true) {
                if (!isHourUpdatable) {
                    lock.wait();
                } else if (isHourUpdatable) {
                    hours++;
                    isHourUpdatable = false;
                    if (hours.equals(hour24LastNum)) {
                        hours = 0;
                    }

                    displayTime();
                }

                lock.notifyAll();
            }
        }
    }

    public void displayTime() {
        System.out.println(hours + COLON + minutes + COLON + seconds);
    }

}


/**
 * 
 */
package com.nagihome.clock;

/**
 * @author Nagi
 * 
 */
public class SecondsThread implements Runnable {

    private ThreadAlarmClock clock;

    public SecondsThread(ThreadAlarmClock clock) {
        this.clock = clock;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        try {
            clock.updateSeconds();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


/**
 * 
 */
package com.nagihome.clock;

/**
 * @author Nagi
 * 
 */
public class MinutesThread implements Runnable {

    private ThreadAlarmClock clock;

    public MinutesThread(ThreadAlarmClock clock) {
        this.clock = clock;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        try {
            clock.updateMinutes();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


/**
 * 
 */
package com.nagihome.clock;

/**
 * @author Nagi
 * 
 */
public class HoursThread implements Runnable {

    private ThreadAlarmClock clock;

    public HoursThread(ThreadAlarmClock clock) {
        this.clock = clock;
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        try {
            clock.updateHours();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


/**
 * 
 */
package com.nagihome.main;

import com.nagihome.clock.HoursThread;
import com.nagihome.clock.MinutesThread;
import com.nagihome.clock.SecondsThread;
import com.nagihome.clock.ThreadAlarmClock;

/**
 * @author Nagi
 * 
 */
public class Main {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        ThreadAlarmClock clock = new ThreadAlarmClock();

        new Thread(new SecondsThread(clock)).start();
        new Thread(new MinutesThread(clock)).start();
        new Thread(new HoursThread(clock)).start();         
    }

}

Solution

  • Suggestions:

    • Use internally milliseconds to count, not sec++
    • sleep(1000) does not exatcly sleep 1000 millis, it can be 990' or 1110. so after waking up you check the system time (or nanoTime), and calculate the difference to last wake up time. If for example you detect that you have slept 1010 millis, then next time you sleep only 990 millis.