Почему Thread.Sleep ведёт себя неправильно? Как мне сделать задержку или длинные вычисления в графической программе?

Question

Мне нужно выводить информацию пользователю с задержкой. К примеру, менять содержимое текстовой метки каждую секунду. (Или выводить промежуточные результаты длинных вычислений.) В программах командной строки я делал так:

Console.WriteLine("значение 1");
Thread.Sleep(1000);
Console.WriteLine("значение 2");
Thread.Sleep(1000);
Console.WriteLine("значение 3");

Это работало. Теперь мне нужно сделать то же самое в графической программе. Я написал метод

void OnClick(object sender, EventArgs args)
{
    label.Text = "значение 1";
    Thread.Sleep(1000);
    label.Text = "значение 2";
    Thread.Sleep(1000);
    label.Text = "значение 3";
}

но он работает как-то не так. Промежуточные значения не показываются, а программа надолго перестаёт реагировать. А когда она отвисает, сразу показывает последнее значение.

Что происходит? Почему программа ведёт себя неправильно, и как же сделать правильно?

Answer 1

Графические программы отличаются от консольных тем, что в них главный поток занимается многими вещами. В консольной программе у нас есть полный контроль, мы полностью управляем её пробегом. В графических программах мы запускаем приложение, и фреймворк для нас создаёт цикл сообщений. В этом цикле фреймворк обрабатывает передвижение мыши, нажатия на клавиши, изменения размеров окна, колбеки от таймера и тому подобные штуки, а также вызывает наши обработчики событий, по одному на итерацию цикла (окей, это упрощённая картина, но для целей изложения подойдёт). После отработки итерации цикла выполнение переходит к следующей итерации.

Всё это работает в одном и том же потоке, который называется UI-потоком.

Теперь, что происходит, если мы в UI-потоке выполняем Thread.Sleep(1000)? А вот что: поток блокируется и ничего не делает целую секунду. Эту самую секунду наш цикл сообщений простаивает, потому что поток выполнения заблокирован нами! Эту секунду не обрабатываются оконные сообщения, не происходит реакция на мышь, не вызываются колбеки, и даже не перерисовывается содержимое окна — ведь всё это делается в том же самом цикле сообщений, который мы и заблокировали!

Чтобы программа работала нормально, наши обработчики событий (наподобие OnClick), конструкторы объектов, и вообще весь код, бегущий в UI-потоке, должны пробегать максимально быстро, без задержек.

Как же сделать паузу в одну секунду? К счастью, в современной версии языка (начиная с C# 5) есть простое решение. Это async/await. Сделаем наш обработчик асинхронным (ключевое слово async), и заменим Thread.Sleep на await Task.Delay:

async void OnClick(object sender, EventArgs args)
{
    label.Text = "значение 1";
    await Task.Delay(1000);
    label.Text = "значение 2";
    await Task.Delay(1000);
    label.Text = "значение 3";
}

Этот метод работает правильно!¹

Что же произошло? Дело в том, что await Task.Delay на время ожидания не блокирует поток. На время ожидания метод как бы прекращает своё выполнение, и цикл сообщений больше не блокируется. [Будьте внимательны, он может быть заблокирован ещё где-то.] Когда ожидание оканчивается, цикл сообщений возобновляет выполнение метода с прерванной точки, до следующего await или до конца метода.²

Таким образом, наш код больше не блокирует UI-поток, и фреймворк может и дальше отрисовывать окно и заниматься прочими служебными заданиями.

---

А что делать, если вместо задержки нужно выполнить какие-то вычисления? Их так просто не вырезать из хода выполнения функции, они всё равно должны быть выполнены. Для этих целей их можно выгрузить в другой поток. Не пугайтесь, это очень просто. Вместо кода

label.Text = "парсим большой файл";
size = ParseBigFile();
label.Text = "закончили, результат = " + size;

вы пишете вот что:

label.Text = "парсим большой файл";
size = await Task.Run(() => ParseBigFile());
label.Text = "закончили, результат = " + size;

Task.Run выполняет ваш код в фоновом потоке, а на время этого выполнения функция опять-таки не блокирует UI-поток.³ Профит! Обратите только внимание на то, что из фонового потока нельзя считывать значения из контролов, поэтому их нужно считать заранее:

Было:

label.Text = "парсим большой файл";
size = ParseBigFileFromPath(textbox.Text);
label.Text = "закончили, результат = " + size;

Стало:

label.Text = "парсим большой файл";
string path = textbox.Text; // читаем из контрола в UI-потоке
size = await Task.Run(() => ParseBigFileFromPath(path)); // обращается к переменной
label.Text = "закончили, результат = " + size;

---

В более старых версиях языка, без async/await, приходилось достигать того же самого более сложным образом. Например, заводить таймер, подписываться на его тики, и на них менять значения в контролах. При этом локальные переменные приходилось выносить в поля класса (или в специальную структуру-контекст). Или можно было делать грязные трюки с DoEvents. К счастью, те старые недобрые времена давно прошли.

---

Связанные вопросы:

• Использование метода sleep()
• Работа с многопоточностью в c#
• Работа с Thread.Sleep();
• Thread blocks window wpf

---

¹ Но для остальных асинхронных методов, не обработчиков событий, нам нужно возвращать не void, а Task или какой-нибудь Task<string>, чтобы вызывающий код мог дождаться их окончания и получить результат.

² Изложение грешит упрощениями, так что не принимайте его за истину в последней инстанции. Это примерная картина, а если вы хотите знать точную, лучше всего почитать книги или документацию. Или задать вопрос, если что-то ведёт себя непонятно.

³ Если нужно делать большую и длительную работу в фоновом потоке, то, возможно, имеет смысл выгрузить эту работу целиком и сообщать о результатах в UI через Progress<T>.

Answer 2

В качестве иллюстрации к ответу VladD.

Задача: Организовать выполнение метода со следующими условиями:

1. Метод должен выполнять некую долгую задачу и не блокировать окно программы;
2. Метод должен выводить в окно программы информацию о ходе своего выполнения;
3. В ходе работы метода должна быть предусмотрена возможность отмены его работы по команде пользователя программы.

Решение:

Для выполнения пункта 1 мы воспользуемся async/await и Task.Run().

Для выполнения пункта 2 мы воспользуемся экземпляром Progress<T>

Для выполнения пункта 3 мы воспользуемся, так называемым токеном отмены, который нам предоставит CancellationTokenSource.

У нас должно получится так:

Создадим подсобный класс, в котором будет метод отдающий с задержкой в 100 мсек. последовательно числа от 0 до 1000.

class Iteration
{
    public IEnumerable<int> StartIterator()
    {
        for (int i = 0; i < 1000; i++)
        {
           // Задержка.
           Thread.Sleep(100);

           // Вывод числа i.
           yield return i;
        }
    }
} 

Вот как выглядит наше дальнейшее решение

public partial class Form1 : Form
{

    public Form1()
    {
        InitializeComponent();
    }

    //источник токена отмены
    private CancellationTokenSource _tokenSource;

    // обработчик кнопки Старт
    private async void buttonStart_Click(object sender, EventArgs e)
    {
        // через него будем оповещать о ходе выполнения задачи
        // в нашем случае типизирован будет stringом,
        // т.к. вывод будет осуществляться в Label
        Progress<string> progress = new Progress<string>(text => this.labelOutput.Text = text);

        //готовим токен отмены
        _tokenSource = new CancellationTokenSource();
        CancellationToken cancelToken = _tokenSource.Token;

        //кнопки
        buttonStart.Enabled = false;
        buttonCancel.Enabled = true;

        try
        {
            // ВНИМАНИЕ! Вот запуск нашего долгого метода
            // обратите внимание на передачу параметров
            // токен отмены мы должны передать и в целевой метод
            // и собственно в метод Run()
            await Task.Run(() => DoIteration(cancelToken, progress), cancelToken);
        }
        catch (OperationCanceledException)
        {
            //случай отмены
            this.labelOutput.Text = "0";
        }
        catch (Exception)
        {
            //случай если возникнет какая-то ошибка
            this.labelOutput.Text = "Ошибка";
        }
        finally
        {
            // кнопки
            buttonStart.Enabled = true;
            buttonCancel.Enabled = false;

            // удаляем источник токена отмены
           _tokenSource.Dispose();
        }
    }

    // Это наш долгий метод, который сообщает о ходе своего выполнения
    // и может быть отменен в любой нужный момент
    // обратите внимание на второй параметр IProgress<string> progress
    // здесь должен быть обязательно интерфейс,
    // если случайно нашите Progress<string>, то не найдете Report() 
    private void DoIteration(CancellationToken cancelToken, IProgress<string> progress)
    {
        //создаем экземпляр нашего подсобного класса
        Iteration iteration = new Iteration();

        // типа какая-то полезная работа
        foreach (int number in iteration.StartIterator())
        {
            //отображаем ход работы метода
            progress.Report(number.ToString());

            //выбрасываем исключение в случае нажатия на кнопку отмены
            cancelToken.ThrowIfCancellationRequested();
        }
    }

    //обработчик кнопки Отмены
    private void buttonCancel_Click(object sender, EventArgs e)
    {
        // даем команду на отмену
        _tokenSource.Cancel();
    }
}

P.S. Этот же пример в случае WPF & MVVM

Это XAML

<Window.DataContext>
    <local:MainViewModel />
</Window.DataContext>
<Canvas>
    <ProgressBar Height="18"
                 Canvas.Left="104"
                 Canvas.Top="128"
                 Width="170"
                 Minimum="0"
                 Maximum="1000"
                 Value="{Binding ProgressShow}"/>
    <TextBlock Canvas.Left="288"
               Canvas.Top="130">
        <Run Text="{Binding ProgressShow}" />
        <Run Text="итераций" />
    </TextBlock>
    <Button Content="Старт"
            Command="{Binding StartCommand, Mode=OneTime}"
            Canvas.Left="154"
            Canvas.Top="216"
            Width="75" />
    <Button Content="Отмена"
            Command="{Binding CancelCommand, Mode=OneTime}"
            Canvas.Left="154"
            Canvas.Top="273"
            Width="75" />
</Canvas>

Это ViewModel

public class MainViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    //источник токена отмены
    private CancellationTokenSource _tokenSource;


    //ctor
    public MainViewModel()
    {

    }


    /// <summary>
    /// Для отображения в ProgressBar
    /// </summary>
    private int _ProgressShow;
    public int ProgressShow
    {
        get => _ProgressShow;
        set
        {
            _ProgressShow = value;
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ProgressShow)));
        }
    }

    /// <summary>
    /// Флаг работы долгой задачи
    /// </summary>
    private bool _IsRunning;
    public bool IsRunning
    {
        get => _IsRunning;
        set
        {
            _IsRunning = value;
            //обновление состояния кнопок
            StartCommand.RaiseCanExecuteChanged();
            CancelCommand.RaiseCanExecuteChanged();
        }
    }

    /// <summary>
    /// Кнопка Старт
    /// </summary>
    private RelayCommand _StartCommand;
    public RelayCommand StartCommand
    {
        get => _StartCommand = _StartCommand ?? new RelayCommand(OnStart, CanStart);
    }
    private bool CanStart()
    {
        if (IsRunning)
        {
            return false;
        }
        return true;
    }
    private async void OnStart()
    {
        // через него будем оповещать о ходе выполнения задачи
        Progress<int> progress = new Progress<int>(n => ProgressShow = n);

        //готовим токен отмены
        _tokenSource = new CancellationTokenSource();
        CancellationToken cancelToken = _tokenSource.Token;

        //кнопки
        IsRunning = true;

        try
        {
            // ВНИМАНИЕ! Вот запуск нашего долгого метода
            // обратите внимание на передачу параметров
            // токен отмены мы должны передать и в целевой метод
            // и собственно в метод Run()
            await Task.Run(() => DoIteration(cancelToken, progress), cancelToken);
        }
        catch (OperationCanceledException)
        {
            //случай отмены
            ProgressShow = 0;
        }
        catch (Exception)
        {
            //случай если возникнет какая-то ошибка
            Debug.WriteLine("-->Error");
            ProgressShow = 0;
        }
        finally
        {
            // кнопки
            IsRunning = false;

            // удаляем источник токена отмены
            _tokenSource.Dispose();
        }

    }

    // Это наш долгий метод, который сообщает о ходе своего выполнения
    // и может быть отменен в любой нужный момент
    // обратите внимание на второй параметр IProgress<int> progress
    // здесь должен быть обязательно интерфейс,
    // если случайно нашите Progress<int>, то не найдете Report() 
    private void DoIteration(CancellationToken cancelToken, IProgress<int> progress)
    {
        //создаем экземпляр нашего подсобного класса
        Iteration iteration = new Iteration();

        // типа какая-то полезная работа
        foreach (int number in iteration.StartIterator())
        {
            //отображаем ход работы метода
            progress.Report(number);

            //выбрасываем исключение в случае нажатия на кнопку отмены
            cancelToken.ThrowIfCancellationRequested();
        }

    }


    /// <summary>
    /// Кнопка Отмена
    /// </summary>
    private RelayCommand _CancelCommand;
    public RelayCommand CancelCommand
    {
        get => _CancelCommand = _CancelCommand ?? new RelayCommand(OnCancel, CanCancel);
    }
    private bool CanCancel()
    {
        if (!IsRunning)
        {
            return false;
        }
        return true;
    }
    private void OnCancel()
    {
        _tokenSource.Cancel();
    }
}

Answer 3

using System.Threading;
...
new Thread(new ThreadStart(() => {
    this.Invoke((MethodInvoker)delegate
    {
        label.Text = "значение 1";
    });
    Thread.Sleep(1000);
    this.Invoke((MethodInvoker)delegate
    {
        label.Text = "значение 2";
    });
    Thread.Sleep(1000);
    this.Invoke((MethodInvoker)delegate
    {
        label.Text = "C# 3.0, привет из 2017!";
    });
})).Start();

Answer 4

Thread.Sleep блокирует весь поток. В том числе весь поток, в котором обрабатывается UI, если его там вызвать.

Лично я бы сказал бы что на это есть несколько решений.

Решение №1: async await (советую использовать именно его)

Его расписал Влад, но я повторюсь и распишу его немного короче чисто что бы люди не мотались туда-назад:

async void OnClick(object sender, EventArgs args)
// обрати внимание на модификатор async - он вызывает метод асинхронно как Task 
//не блокируя главный поток
{
    label.Text = "значение 1";
    await Task.Delay(1000);  //Правильная замена Thread.Sleep которая в даном случае всего 
                             //лишь приостанавливает таску, но не блокирует поток
    label.Text = "значение 2";
    await Task.Delay(1000);
    label.Text = "значение 3";
}

Решение №2: использование делегатов (не лучшее решение даной проблемы, но лучше с ним ознакомится)

Суть в чем: в UI потоке ты создаешь делегат который будет делать что-то нужное. Например, обновлять в UI потоке некий progressBar который будет показывать на сколько процентов скачался большой файл. Собственно, сама скачка должна воспроизводится в другом потоке (создай новый тред) или в таске.

На что нужно обратить внимание: используй BeginInvoke(делегат); (запускает метод по ссылке делегата в главном потоке) а не делегат.Invoke(); (запускает метод по ссылке делегата в этом же потоке).

Так же это можно сделать БЕЗ обьявления конкретных инстансов делегатов. K G в своем ответе показал же пример того, как в более старых версиях языка справлялись с задачей. Фактически, он описал именно этот вариант пути, только не обьявлял никаких конкретных делегатов:

using System.Threading;
...
new Thread(new ThreadStart(() => {// Мы описываем что должно делатся в новом потоке
    this.Invoke((MethodInvoker)delegate //мы запускаем код в UI потоке
    {
        label.Text = "значение 1";
    });
    Thread.Sleep(1000); //Мы ждем 1 секунду в даном потоке   
    this.Invoke((MethodInvoker)delegate //мы запускаем код в UI потоке
    {
        label.Text = "значение 2";
    });
    Thread.Sleep(1000); //Мы ждем 1 секунду в даном потоке 
    this.Invoke((MethodInvoker)delegate //мы запускаем код в UI потоке
    {
        label.Text = "C# 3.0, привет из 2017!";
    });
})).Start();//мы запускаем описанный метод в новом потоке

Решение №3: реализация одного из паттернов MVC или MVP или еще любого аналога. (очень даже правильное решение, но более сложное в реализации и громоздкое)

Идея в чем: UI вообще ничего не знает про реализацию программы. Все делается отдельно от UIя. И по-факту реализация логики общается с UIем через прослойку из ивентов.