C# Thread won't sleep?

I have this code :

void Main()
{
    System.Timers.Timer t = new System.Timers.Timer (1000);
    t.Enabled=true;
    t.Elapsed+= (sender, args) =>c();
    Console.ReadLine();

}

int h=0;
public void c()
{
    h++;
    new Thread(() => doWork(h)).Start();
}

public void doWork(int h)
{
    Thread.Sleep(3000);
    h.Dump();
}

I wanted to see what happens if the interval is 1000 ms and the job process is 3000 ms.

However I saw a strange behavior - the 3000 ms delay occurs only at the start !

How can I make each doWork sleep 3000 ms?

As you can see here, at the beginning there is a 3 second delay, and then it iterates 1 second each.

Every time the timer ticks, you start a thread to do some sleeping; that thread is completely isolated, and the timer is going to keep on firing every second. Actually, the timer fires every second even if you move the Sleep(3000) into c().

What you have currently is:

1000 tick (start thread A)
2000 tick (start thread B)
3000 tick (start thread C)
4000 tick (start thread D, A prints line)
5000 tick (start thread E, B prints line)
6000 tick (start thread F, C prints line)
7000 tick (start thread G, D prints line)
8000 tick (start thread H, E prints line)
...

It is unclear what you are trying to do. You could disable the timer when you don't want it firing, and resume it again once ready, but it is unclear what the purpose of the Sleep() is here. Another option is just a while loop with a Sleep() in it. Simple, and doesn't involve lots of threads.

Every second you're starting new thread with 3 sec delay. It happens like this:

1. thread 1 start
2. thread 2 start, thread 1 sleeps
3. thread 3 start, thread 2 sleeps, thread 1 sleeps
4. thread 4 start, thread 3 sleeps, thread 2 sleeps, thread 1 sleeps
5. thread 5 start, thread 4 sleeps, thread 3 sleeps, thread 2 sleeps, thread 1 dumps
6. thread 6 start, thread 5 sleeps, thread 4 sleeps, thread 3 sleeps, thread 2 dumps
7. thread 7 start, thread 6 sleeps, thread 5 sleeps, thread 4 sleeps, thread 3 dumps

As you can see, each thread sleeps for 3 seconds, yet a dump occurs every second.

How do one works with threads? smth like this:

void Main()
{
    new Thread(() => doWork()).Start();
    Console.ReadLine();
}

public void doWork()
{
    int h = 0;
    do
    {
        Thread.Sleep(3000);
        h.Dump();
        h++;
    }while(true);
}