Problems with using Thread.Sleep for short times

Question

I have an app with 2 threads (now), but it seems that function Thread.Sleep() doesn't work very good. It sleeps threads but it takes much more time (for example- I want to sleep it for 5ms and it sleeps for 0,3s or more). Here is code:

int vlakien = 2;
Thread[] vlakna; 
vlakna = new Thread[vlakien];

for (int i = 0; i < vlakien; i++) 
{ try { vlakna[i] = new Thread(new ThreadStart(utok)); vlakna[i].Start(); } }

private void utok()
{
  //some code
  Thread.Sleep(5);
  //some code
}

Also I tried to sleep it with Stopwatch in the function utok and it also takes more time:

Stopwatch SW = new Stopwatch(); SW.Start();
while(SW.ElapsedMilliseconds < 5000) ;

Please help.

Condescension

Yes, Thread.Sleep is not guaranteed to sleep for exactly the specified amount of time. And using it in general is a sign that your application is poorly-designed. It's not clear what problem you're trying to use it to solve. Consider updating your question with a discussion of the real problem, rather than your failed solution. – Estimate

I am sending a huge amount of packets with sharppcap and packetdotnet (DoS attack simulation [diploma work]) and I want to simulate it with small delays between packets (without delay/5ms delay/10ms delay...). – Condescension

Answer 1

15ms is the thread time slice on windows ( you can actually mess with windows and change that.... not at all recommended). Things can give their time slices up early, but anything could take their full time slice.

So its really hard to get any better than that, in fact, realistically 20 or 30 ms is more likely. I used to do real time processing which had a hard real time limit of 50ms. That worked well on windows if you obeyed certain rules ( it was in C++)

Feral

Is there any article in MSDN to provide proof for this? – Airy

This is for Task.Delay but probably same goes for Thread.Sleep... msdn.microsoft.com/en-us/library/hh194845(v=vs.110).aspx – Frere

Answer 2

As others have indicated, the default resolution of Sleep is 10 or 15 milliseconds, depending on the edition of Windows.

However, you can reprogram the timer to use a 1 millisecond resolution by issuing a

timeBeginPeriod(1);
timeEndPeriod(1);

where

[DllImport(WINMM)]
internal static extern uint timeBeginPeriod(uint period);   

We do this in our serial communications services where being able to accurately space out sends in time is important. Some people are reluctant to do this because it causes Windows to do other things that are based off of the timer more frequently as well. In reality this has caused no discernible issues for us, and we have hundreds of installs each with hundreds of serial devices connected.

Hertel

It wouldn't be a problem on a dedicated machine, but I'd hardly recommend it for general use. And if your installer ever did that to a machine of mine, I'd probably go postal. More to the point, this still doesn't ensure that the timer actually uses a 1 millisecond resolution. Windows is still not a real-time operating system. – Estimate

These are dedicated machines. And you are of course correct that this does not alter the fact that Windows is not a real-time OS. – Hertel

It looks like you're supposed to call timeEndPeriod as well - "You must match each call to timeBeginPeriod with a call to timeEndPeriod, specifying the same minimum resolution in both calls." msdn.microsoft.com/en-us/library/windows/desktop/… – Diffractive

Answer 3

Sleep in Microsoft C# guarantees a minimum amount of time. It sleeping less than 5 milliseconds is definitely a problem. Also Stopwatch may not be very precise measurement, try the high precision media timers.

Beore

I disagree Stopwatch will provide high precision timing just as the media timers. As far as I know it's the same timer that media timers use which is the QueryPerformanceCounter. I know of no other hi resolution timer on a standard windows PC. – Supersaturated

Answer 4

This is a Platform Dependent Wait you can use in any project that works by suspending the Thread for the amount of time you specify with the lowest possible resolution that can be achieved by your system, which will likely be 1ms

It won't use more CPU than a normal Thread.Sleep

/*
*MIT License
*
*Copyright (c) 2023 S Christison
*
*Permission is hereby granted, free of charge, to any person obtaining a copy
*of this software and associated documentation files (the "Software"), to deal
*in the Software without restriction, including without limitation the rights
*to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*copies of the Software, and to permit persons to whom the Software is
*furnished to do so, subject to the following conditions:
*
*The above copyright notice and this permission notice shall be included in all
*copies or substantial portions of the Software.
*
*THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*SOFTWARE.
*/

using System.Runtime.InteropServices;

namespace System.Threading
{
    /// <summary>
    /// Platform Dependent Wait
    /// Accurately wait down to 1ms if your platform will allow it
    /// Wont murder your CPU
    public static class Delay
    {
        internal const string windowsMultimediaAPIString = "winmm.dll";

        [DllImport(windowsMultimediaAPIString)]
        internal static extern int timeBeginPeriod(int period);

        [DllImport(windowsMultimediaAPIString)]
        internal static extern int timeEndPeriod(int period);

        [DllImport(windowsMultimediaAPIString)]
        internal static extern int timeGetDevCaps(ref TimerCapabilities caps, int sizeOfTimerCaps);

        internal static TimerCapabilities Capabilities;

        static Delay()
        {
            timeGetDevCaps(ref Capabilities, Marshal.SizeOf(Capabilities));
        }

        /// <summary>
        /// Platform Dependent Wait
        /// Accurately wait down to 1ms if your platform will allow it
        /// Wont murder your CPU
        /// </summary>
        /// <param name="delayMs"></param>
        public static void Wait(int delayMs)
        {
            timeBeginPeriod(Capabilities.PeriodMinimum);
            Thread.Sleep(delayMs);
            timeEndPeriod(Capabilities.PeriodMinimum);
        }

        /// <summary>
        /// The Min/Max supported period for the Mutlimedia Timer in milliseconds
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct TimerCapabilities
        {
            /// <summary>Minimum supported period in milliseconds.</summary>
            public int PeriodMinimum;

            /// <summary>Maximum supported period in milliseconds.</summary>
            public int PeriodMaximum;
        }
    }
}

This will work with any version of .NET and if your platform doesn't support this then it is the same as a normal Thread.Sleep

Amido

Answer 5

It is affected by resolution of the system clock. It is around 15ms...you cannot go below resolution of the system clock. Take a look at this link (it is C++ but you will get idea about timer resolutions).

Alb

Answer 6

The parameter passed into Thread.Sleep is a minimum time to sleep, not an exact time.

Oujda