Как сделать метод потокобезопасным [закрыто]

Я беру на себя смелость добавления второго ответа, поскольку теперь кажется, что ключевая роль вопроса была то, как отменить блокировку (т.е. выпустить ее после нескольких секунд).

Однако не имеет смысла отменять блокировку (с "внешней стороны" блокировки), не отменяя работу, которая делается в блокировке. Если Вы не отменяете работу, которая делается в блокировке тогда, она может делать попытку продолженного доступа к дефицитному ресурсу, приводящему к двум потокам с помощью ресурса одновременно. Что нужно сделать, вместо того, чтобы повредить блокировку снаружи, нужно отменить сделанную работу, который тогда приведет к блокировке, вышедшей тем рабочим.

комментарий А по поводу поточной обработки и отмены. Не нужно прерывать потоки, потому что в целом это оставляет программу (например, ресурсы сохраненный тем потоком) в неопределенном состоянии. Это были много лет, с тех пор как задачи и отмена задачи были представлены. Задачей является по существу операция или метод, который ставится в очередь, чтобы быть выполненным, наряду с другими Задачами, на потоках, полученных из, например, пул потоков. В эти дни в значительной степени весь недавний код должен быть основан на задачах и следовать за совместным подходом отмены задачи. Следующий код показывает, как сделать это, включая запуск задачи на пуле потоков.

Примечание я использую класс MethodLock, представленный в моем более раннем ответе; это - просто обертка для SemaphoreSlim.

Вот класс Рабочего, который делает некоторую работу с дефицитным ресурсом (и некоторые без ресурса). Это сотрудничает в отмене путем тестирования CancellationToken время от времени. Если отмену требовали тогда, рабочий отменяет себя путем выдачи специального исключения.

        public class Worker
        {
            public Worker(int workerId, CancellationToken ct, int howMuchWorkToDo)
            {
                this.WorkerId = workerId;
                this.CancellationToken = ct;
                this.ToDo = howMuchWorkToDo;
                this.Done = 0;
            }
            public int WorkerId { get; }
            public CancellationToken CancellationToken { get; }
            public int ToDo { get; }
            public int Done { get; set; }

            static MethodLock MethodLock { get; } = new MethodLock();

            public async Task DoWorkAwareAsync()
            {
                this.CancellationToken.ThrowIfCancellationRequested();
                this.Done = 0;
                while (this.Done < this.ToDo) {
                    await this.UseCriticalResourceAsync();
                    await this.OtherWorkAsync();
                    this.CancellationToken.ThrowIfCancellationRequested();
                    this.Done += 1;
                }
                Console.WriteLine($"Worker {this.WorkerId} completed {this.Done} out of {this.ToDo}");
            }

            private async Task UseCriticalResourceAsync()
            {
                using (await MethodLock.LockAsync()) {
                    //Console.WriteLine($"Worker {this.WorkerId} acquired lock on critical resource.");
                    await Task.Delay(TimeSpan.FromMilliseconds(50));
                }
            }
            private async Task OtherWorkAsync()
            {
                await Task.Delay(TimeSpan.FromMilliseconds(50));
            }
        }

Теперь позволяют нам посмотреть на то, как запустить много второстепенных рабочих и помешать им работать слишком долго, т.е. отменять их после нескольких секунд. Обратите внимание, что это настраивается как консольное приложение.

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

        static void Main(string[] args)
        {
            Random rand = new Random( DateTime.Now.Millisecond);

            Console.WriteLine("---- Cancellation-aware work");
            Task[] tasks = new Task[10];
            for (int i = 0; i < 10; i++) {
                CancellationTokenSource cts = new CancellationTokenSource();
                cts.CancelAfter(TimeSpan.FromMilliseconds(2000));
                int howMuchWork = (rand.Next() % 10) + 1;
                Worker w = new Worker(i, cts.Token, howMuchWork);
                tasks[i] = Task.Run(
                    async () => {
                        try {
                            await w.DoWorkAwareAsync();
                        } catch (OperationCanceledException) {
                            Console.WriteLine($"Canceled worker {w.WorkerId}, work done was {w.Done} out of {w.ToDo}");
                        }
                    },
                    cts.Token
                );
            }
            try {
                Task.WaitAll(tasks);
            } catch (AggregateException ae) {
                foreach (Exception e in ae.InnerExceptions) {
                    Console.WriteLine($"Exception occurred during work: {e.Message}");
                }
            }
            Console.ReadKey();
        }

я прокомментировал бы что присутствие "cts. Маркер" как второй аргумент Задаче. Выполненный НЕ касается принудительного / трудная отмена задачи, созданной Задачей. Выполненный метод. Вся та Задача. Выполненный делает с этим вторым аргументом, сравнивают его с маркером отмены в исключении отмены, и если это - то же тогда Задача. Выполненный переходит задача к Отмененному состоянию.

при выполнении этого, Вы будете видеть что-то как следующее:

    ---- Cancellation-aware work
    Worker 5 completed 1 out of 1
    Worker 2 completed 1 out of 1
    Worker 8 completed 1 out of 1
    Worker 6 completed 3 out of 3
    Worker 7 completed 3 out of 3
    Canceled worker 3, work done was 4 out of 5
    Canceled worker 4, work done was 4 out of 10
    Canceled worker 1, work done was 4 out of 8
    Canceled worker 9, work done was 4 out of 7
    Canceled worker 0, work done was 5 out of 9

Снова, этот дизайн предполагает, что методы рабочего сотрудничают с отменой. Если Вы работаете с унаследованным кодом, где операция рабочего не сотрудничает в прислушивании к запросам отмены тогда, может быть необходимо создать поток для той операции рабочего. Это требует надлежащей очистки, и кроме того она может создать проблемы производительности, потому что она израсходовала потоки, которые являются ограниченным ресурсом. Ответ Simon Mourier посреди этого связанного обсуждения показывает, как сделать это: это возможный прервать Задачу как прерывание Потока (Поток. Метод аварийного прекращения работы)?