Pause of a Thread ?

Thread.Sleep pauses the thread in which it is caused. If you call Thread.Sleep from the same thread that uses the timer (usually the UI thread), then yes, it will prevent the thread from handling the timer events.

1.Why not Thread.Sleep(x) or Thread.SpinWait(x)?
2. Timer runs on separate thread.
3. Try Thread.Interrupt()[^].

bool interrupt;
public void PauseCheck(int x)
{
    for (int i = 0; i < (x / 10); i++)
    {
      If(interrupt) break;
      Thread.Sleep(10);
    }
}
public void OnTimer
{
interrupt = true;
}

It seems to work for me. Are you sure you're calling Timer.Start() when you should? Here is how I tested it:

DateTime start = DateTime.Now;
TimeSpan timespan = new TimeSpan(0,0,0);
volatile AutoResetEvent evnt = new AutoResetEvent(false);
private void button1_Click(object sender, EventArgs e)
{
    System.Timers.Timer timer;
    timer = new System.Timers.Timer();
    timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
    timer.Interval = 5000;
    timer.Start();
    start = DateTime.Now;
    PauseCheck(10000);
    evnt.WaitOne();
    MessageBox.Show("Time: " + timespan);

}

void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
    timespan = DateTime.Now - start;
    evnt.Set();
}

public void PauseCheck(int x)
{
    for (int i = 0; i < (x / 10); i++)
    {
        System.Threading.Thread.Sleep(10);
    }
}

Result: "Time: 00:00:05.0005000"

Take a look at Thread Synchronization[^] and under "Synchronization Events and Wait Handles".

You can use a ManualResetEvent like this:

ManualResetEvent stopEvent = new ManualResetEvent(false);

while (stopEvent.WaitOne(1000) == false)
{
 // Wait for 1 sec or stop it stopEvent is signaled.
}

// When timer tick, stop while loop.
void OnTimer(object sender, System.Timers.ElapsedEventArgs e)
{
  stopEvent.Set();
}

I didn't fully understood your question. However the answer is Thread.Sleep is a blocking call. It blocks the thread. If your need is executing the timer independent of the blocked thread then use a thread timer which run in a new thread. For example

private System.Threading.Timer tmr;
private void button1_Click(object sender, EventArgs e)
{
    tmr= new System.Threading.Timer(new TimerCallback(OnTimer),Thread.CurrentThread,0,5000);
    tmr.Change(0, 5000);
    PauseCheck(50000);
 }
protected void OnTimer(object obj)
{
    MessageBox.Show("Timer Event is running without pausing");
    Thread t = (Thread)obj;
    t.Interrupt();
}
public void PauseCheck(int x)
{
    for (int i = 0; i < (x / 10); i++)
    {
        try
        {
            Thread.Sleep(10);
        }
        catch (ThreadInterruptedException e) { break; }
    }
    tmr.Dispose();
    MessageBox.Show("Paused Thread is active now");
}

In the above example the timer event run regardless of the blocked thread. But you can't do anything on the blocked thread. In that case instead of sleep you could consider spin wait. Spin wait not work on milliseconds but on iterations.

It seems to me that you should utilize 2 threads atleast and a single thread for each philosopher...

1 Thread is the Main thread.
1 Thread is the Timer Thread

The main thread should start and kick of the timer thread. It should then start up threads for each actor.In the program just ensure you create a Thread[] PhilsopherThreads and each philosopher you create should be created and put to work in one of those threads.

The timer thread should have a high resolution tick such as 1000 ms or 500 ms, this should possibly use Interlocked.CompareExchange to indicate the tick has come by incrementing a private varaible or setting the private varible to DateTime.Now.

In your main thread you will make a worker thread for each actor in your program. In this case the philosopher. Each philosopher thread will follow its logic observing the private variable to determine if he should stop working or continue to work.

In this scenario a philosopher can work or not work as long as he wants. He can observe the private varible to determine if he needs to work further or not. He can be interrupted by the timers as well as by other philosopher threads.

In your main thread you would set the priority to lowest or below normal and while any PhilsopherThreads are working you can SpinWait(0) or Sleep(-1) in the main thread.

At the end of all philosopher threads which are working you can then exit the main thread or do whatever you want to do.


That is how I see it IMHO.

OK, now that I know you're trying to solve the dining philosophers problem, may I suggest that you create one class called philospher and encapsulate all "philospher"-related logic in it. Each one could use a timer to initiate the state change from thinking to eating. Then you can create five instances of this class and observe their behavior.

You'll probably want to create a set of "fork" objects and link to the appropriate philosopher's right and left side somehow. Use Mutexes to simulate the taking of the forks.

I will clarify about timers and the Sleep function.

1- System.Threading.Sleep blocks the calling thead
2- A System.Threading.Timer or a System.Timers.Timer executes from a dedicated thread, therefore the callback will be called even if the thread which instanciated the timer is sleeping.
3- A System.Windows.Forms.Timer executes from the main thread, therefore the callback will not be called if the main thread is sleeping.

Do this simple test to convince yourself:

static class Program
{
    [STAThread]
    static void Main()
    {
        //uncomment the function you want to test
        //TestThreading();
        //TestTimers();
        //TestWinForms();
    }
    static void TestThreading()
    {
        //"Timer" will be printed every second
        System.Threading.Timer timer = new System.Threading.Timer(
            e => Console.WriteLine("Timer"),
            null, 0, 1000);
        System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
        timer.Dispose();
    }
    static void TestTimers()
    {
        //"Timer" will be printed every second
        System.Timers.Timer timer = new System.Timers.Timer(1000);
        timer.Elapsed += (sender, e) => Console.WriteLine("Timer");
        timer.Enabled = true;
        System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
        timer.Dispose();
    }
    static void TestWinForms()
    {
        //"Timer" will never be printed
        System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
        timer.Interval = 1000;
        timer.Tick += (sender, e) => Console.WriteLine("Timer");
        timer.Enabled = true;
        System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
        timer.Dispose();
    }
}

For the Windows.Forms.Timer, you can replace the infinite sleep with a Sleep(10) inside a loop if you want, but it will not change anything since you are still inside your function. The callback will be called only if your main thread is not busy. Not busy here means you handled all UI events (button clicks, keyboards, ...) and you are waiting for the next event.