CareerCup

from threading import Thread, Lock
import time

class TimeException(Exception):
	pass

class Timer:
	def __init__(t, init):
		t.init = init
		t.lock = Lock()
		t.kill = False

	def timer_thread(t):
		t.current = t.init
		while True:
			try:
				t.lock.acquire()

				if t.current<= 0: break
				if t.kill: break
				
				t.current -= 1
				print t.current
			finally:
				t.lock.release()			
			time.sleep(1)
	
	def reset(t):
		try:
			t.lock.acquire()
			t.current = t.init
		finally:
			t.lock.release()
	
	def stop(t):
		try:
			t.lock.acquire()
			t.kill = True
		finally:
			t.lock.release()

	def time(t):
		try:
			t.lock.acquire()
			return t.current
		finally:
			t.lock.release()

	def start(t):
		Thread(target=t.timer_thread).start()

t = Timer(5)
t.start()
time.sleep(2)
t.reset()
time.sleep(2)
t.stop()

Simple implementation would be like this.

#include System;
#include System.Threading;
#include System.Timers;

public class ThreadSafeTimer
{
	private Object thisLock = new Object();
	
	public static void Main()
	{
		public static Timer t = new Timer();
		StartTimer(t);
		StopTimer(t);
		ResetTimer(t);
	}
	
	public static void StartTimer(Timer t)
	{
		lock(thisLock)
		{
			if(!t.Enabled)
			{
				t.Start();
			}
		}
	}
	
	public static void StopTimer(Timer t)
	{
		lock(thislock)
		{
			if(t.Enabled)
			{
				t.Stop();
			}
		}
	}
	
	public static void ResetTimer(Timer t)
	{
		lock(thisLock)
		{
			if(!t.Enabled)
			{
				t.Reset();
			}
		}
	}
}

class Timer{
public:
    
    Timer():_start(0),_stop(0)
    {
    }
    void start()
    {
        std::lock_guard<std::mutex> g(_mutex);
        time(&_start);
    }
    double stop()
    {
        std::lock_guard<std::mutex> g(_mutex);
        time(&_stop);
        double res = difftime(_stop,_start);
        std::cout << "Elapsed: " << res << std::endl;
        return res;
    }
    void reset()
    {
        std::lock_guard<std::mutex> g(_mutex);
        _start=0;
        _stop=0;
    }
private:
    std::mutex _mutex;
    time_t _start;
    time_t _stop;
    

};

int main(int argc, const char * argv[]) 
{

    Timer timer;
    std::vector<std::thread> workers;
    for (int i = 0; i < 15; i++) {
        workers.push_back(std::thread([&]()
                                      {
                                          if ( i%2 )
                                              timer.start();
                                          else if (!( i%2 ) )
                                              timer.stop();
                                          if ( i%3 )
                                              timer.reset();
                                      }));
        workers[workers.size()-1].join();
    }
    timer.start();
    this_thread::sleep_for(std::chrono::seconds(5));
    timer.stop();
    std::cout << "Hello, World!\n";
    return 0;
}

#include <chrono>
#include <mutex>
#include <thread>
#include <condition_variable>
#include <iostream>

class ThreadSafeTimer {
private:
    std::mutex mtx;
    std::chrono::steady_clock::time_point start_time;
    std::chrono::duration<double> elapsed{0};
    bool running = false;

public:
    void Start() {
        std::lock_guard<std::mutex> lock(mtx);
        if (!running) {
            start_time = std::chrono::steady_clock::now();
            running = true;
        }
    }

    void Stop() {
        std::lock_guard<std::mutex> lock(mtx);
        if (running) {
            auto end_time = std::chrono::steady_clock::now();
            elapsed += end_time - start_time;
            running = false;
        }
    }

    void Reset() {
        std::lock_guard<std::mutex> lock(mtx);
        running = false;
        elapsed = std::chrono::duration<double>::zero();
    }

    double Elapsed() {
        std::lock_guard<std::mutex> lock(mtx);
        if (running) {
            auto current_time = std::chrono::steady_clock::now();
            return std::chrono::duration_cast<std::chrono::duration<double>>(elapsed + (current_time - start_time)).count();
        }
        return elapsed.count();
    }
};

int main() {
    ThreadSafeTimer timer;

    timer.Start();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    timer.Stop();

    std::cout << "Elapsed time: " << timer.Elapsed() << " seconds" << std::endl;

    timer.Reset();
    timer.Start();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Elapsed time after reset and 2 seconds: " << timer.Elapsed() << " seconds" << std::endl;

    return 0;
}

Output:

Elapsed time: 1.00007 seconds
Elapsed time after reset and 2 seconds: 2.00007 seconds