Чому Thread.Sep так шкідливий

Я часто бачу, як згадується, що Thread.Sleep();його не слід використовувати, але я не можу зрозуміти, чому це так. Якщо це Thread.Sleep();може спричинити неприємності, чи є альтернативні рішення з таким же результатом, які були б безпечними?

напр.

while(true)
{
    doSomework();
    i++;
    Thread.Sleep(5000);
}

ще один:

while (true)
{
    string[] images = Directory.GetFiles(@"C:\Dir", "*.png");

    foreach (string image in images)
    {
        this.Invoke(() => this.Enabled = true);
        pictureBox1.Image = new Bitmap(image);
        Thread.Sleep(1000);
    }
}

Проблеми , пов'язані з викликом Thread.SleepARE пояснюється досить лаконічно тут :

Thread.Sleepмає своє використання: моделювання тривалих операцій під час тестування / налагодження на потоці MTA. У .NET немає інших причин використовувати його.

Thread.Sleep(n)означає блокувати поточний потік щонайменше за кількість часових шрифтів (або квантів потоку), які можуть виникнути протягом n мілісекунд. Довжина часового відрізка різна в різних версіях / типах Windows та різних процесорах і зазвичай становить від 15 до 30 мілісекунд. Це означає, що нитка майже гарантовано блокується більше, ніж nмілісекунд. Ймовірність того, що ваша нитка знову пробудеться через nмілісекунди, настільки ж неможлива, наскільки це неможливо. Отже, Thread.Sleepбезглуздо для термінів .

Нитки - це обмежений ресурс, для створення їх потрібно приблизно 200 000 циклів і знищити близько 100 000 циклів. За замовчуванням вони резервують 1 мегабайт віртуальної пам'яті для її стека і використовують 2000-8000 циклів для кожного контекстного комутатора. Це робить будь-яку нитку очікування величезною тратою.

Краще рішення: WaitHandles

Найбільш помилковою помилкою є використання Thread.Sleepконструкції while ( демонстрація та відповідь , приємний запис у блозі )

EDIT:
Я хотів би покращити свою відповідь:

У нас є 2 різних випадки використання:

1. Ми чекаємо , тому що ми знаємо конкретний відрізок часу , коли ми повинні продовжувати (використовувати Thread.Sleep, System.Threading.Timerабо двійники)

2. Ми чекаємо, оскільки деякий час змінюється якийсь час ... ключове слово (и) є / є деякий час ! якщо перевірка стану знаходиться в нашому кодовому домені, ми повинні використовувати WaitHandles - інакше зовнішній компонент повинен передбачати якісь гачки ... якщо це не його дизайн поганий!

Моя відповідь переважно стосується випадку 2

SCENARIO 1 - чекайте завершення завдання асинхронізації: я погоджуюся, що WaitHandle / Auto | ManualResetEvent слід використовувати в сценарії, коли нитка чекає завершення завдання на іншому потоці.

SCENARIO 2 - синхронізація під час циклу: Однак, як сирий механізм синхронізації (у той час як + Thread.Sleep) ідеально добре для 99% програм, які НЕ вимагають точно знати , коли заблокована нитка повинна "прокинутися". Аргумент, який потрібно 200k циклів для створення потоку також недійсні - нитка циклу синхронізації повинна бути створена в будь-якому випадку, і 200k циклів - лише ще одне велике число (скажіть мені, скільки циклів відкрити файл / сокет / db дзвінки?).

Тож якщо хоч + Thread.Sleep працює, навіщо ускладнювати речі? Тільки синтаксичних адвокати, бути практичними !

Я хотів би відповісти на це запитання з точки зору політики кодування, яка може чи не може бути корисною для будь-кого. Але особливо коли ви маєте справу з інструментами, призначеними для корпоративних програмістів 9-5, люди, які пишуть документацію, як правило, використовують слова типу "не слід" і "ніколи" не означають "цього не робити, якщо ви дійсно не знаєте, що ви ти робиш і чому ".

Кілька моїх улюблених у світі C # - це те, що вони говорять вам "ніколи не дзвоніть блокувати (це)" або "ніколи не дзвоніть GC.Collect ()". Ці двоє насильно декларуються у багатьох блогах та офіційній документації, а ІМО - це повна дезінформація. На деякому рівні ця дезінформація служить своїй меті, оскільки вона не дозволяє новачкам робити те, чого вони не розуміють, перш ніж повністю вивчити альтернативи, але в той же час ускладнює пошук реальної інформації за допомогою пошукових систем, які всі здається, вказують на статті, які говорять вам про те, щоб не робити чогось, не пропонуючи відповіді на питання "чому б і ні?"

Політично це зводиться до того, що люди вважають "хорошим дизайном" або "поганим дизайном". Офіційна документація не повинна диктувати дизайн моєї заявки. Якщо є справді технічна причина, що ви не повинні викликати сон (), то в документації ІМО повинно бути зазначено, що цілком нормально називати його за певними сценаріями, але, можливо, пропонувати деякі альтернативні рішення, які не залежать від сценарію або підходять для іншого сценаріїв.

Чіткий виклик "сну ()" корисний у багатьох ситуаціях, коли строки чітко визначені в реальному часі, однак існують більш досконалі системи для очікування та сигналізації потоків, які слід враховувати та розуміти, перш ніж починати кидати сон ( ) у свій код, і кидання зайвих висловлювань сну () у ваш код, як правило, вважається тактикою для початківців.

Люди застерігають саме 1) .спінінг та 2). Цикл опитування ваших прикладів , а не частина Thread.Sleep (). Я думаю, що Thread.Sleep () зазвичай додається для легкого вдосконалення коду, який крутиться або знаходиться в циклі опитування, тому він просто асоціюється з "поганим" кодом.

Крім того, люди роблять такі речі, як:

while(inWait)Thread.Sleep(5000); 

де змінна inWait не має доступу до потоку, що також спричиняє проблеми.

Програмісти хочуть бачити - це потоки, керовані структурами "Події" та "Сигналізація та блокування", і коли ви цього не зробите, Thread.Sleep (), а також занепокоєння щодо безпечного потокового змінного доступу також усувається. Як приклад, чи можете ви створити обробник подій, пов’язаний з класом FileSystemWatcher, і використати подію для запуску 2-го прикладу замість циклу?

Як згадував Андреас Н., читайте " Threading in C #" Джо Альбахарі , це дійсно добре.

Сон використовується в тих випадках, коли незалежна програма (програми), над якою ви не маєте контролю, іноді може використовувати загальновживаний ресурс (скажімо, файл), до якого вашій програмі потрібно отримати доступ, коли вона працює, і коли цей ресурс використовується цими інших програм вашій програмі заборонено використовувати її. У цьому випадку, коли ви отримуєте доступ до ресурсу у своєму коді, ви ставите свій доступ до ресурсу у спробі лову (щоб вилучити виняток, коли ви не можете отримати доступ до ресурсу), і ви ставите це в циклі часу. Якщо ресурс вільний, сон ніколи не викликається. Але якщо ресурс заблокований, ви спите протягом відповідної кількості часу та намагаєтесь знову отримати доступ до ресурсу (саме тому ви циклічно). Однак майте на увазі, що на петлю потрібно поставити якийсь обмежувач, тому це не потенційно нескінченна петля.

У мене є випадок використання, який я не дуже бачу тут, і я стверджую, що це поважна причина використання Thread.Sleep ():

У консольному додатку, що виконує завдання очищення, мені потрібно здійснити велику кількість досить дорогих дзвінків до бази даних, до БД, якими поділяються тисячі одночасних користувачів. Щоб не забивати БД і не виключати інших протягом годин, мені знадобиться пауза між дзвінками, порядку 100 мс. Це не пов’язано з тимчасовим часом, а лише з отриманням доступу до БД для інших потоків.

Витрата 2000-8000 циклів на перемикання контексту між дзвінками, на виконання яких може знадобитися 500 мс, є доброякісним, як і у 1 стека MB для потоку, який працює як один екземпляр на сервері.

Я згоден з багатьма тут, але також думаю, що це залежить.

Нещодавно я зробив цей код:

private void animate(FlowLayoutPanel element, int start, int end)
{
    bool asc = end > start;
    element.Show();
    while (start != end) {
        start += asc ? 1 : -1;
        element.Height = start;
        Thread.Sleep(1);
    }
    if (!asc)
    {
        element.Hide();
    }
    element.Focus();
}

Це була проста анімаційна функція, і я її використовував Thread.Sleep .

Мій висновок, якщо це виконує роботу, використовуйте його.

Для тих із вас, хто не бачив жодного вагомого аргументу проти використання Thread.Sleep в SCENARIO 2, дійсно є один - вихід програми триматиметься циклом while (SCENARIO 1/3 - просто дурний, тому не вартий більше згадуючи)

Багато хто, хто претендує на те, що він знає, кричить Тема. Сон - це зло, не вдалося згадати єдиної поважної причини для тих із нас, хто вимагав практичної причини не використовувати його - але ось це, завдяки Піту - Thread.Sleep є Злом (його можна легко уникнути за допомогою таймера / обробника)

    static void Main(string[] args)
    {
        Thread t = new Thread(new ThreadStart(ThreadFunc));
        t.Start();

        Console.WriteLine("Hit any key to exit.");
        Console.ReadLine();

        Console.WriteLine("App exiting");
        return;
    }

    static void ThreadFunc()
    {
        int i=0;
        try
        {
            while (true)
            {
                Console.WriteLine(Thread.CurrentThread.ThreadState.ToString() + " " + i);

                Thread.Sleep(1000 * 10);
                i++;
            }
        }
        finally
        {
            Console.WriteLine("Exiting while loop");
        }
        return;
    }