关于c＃：使用Thread.Sleep（）总是坏的吗？

Is it always bad to use Thread.Sleep()?

我为类Random创建了一个扩展方法，它在随机时间执行Action(void委托)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static class RandomExtension
{
private static bool _isAlive;
private static Task _executer;

public static void ExecuteRandomAsync(this Random random, int min, int max, int minDuration, Action action)
{
Task outerTask = Task.Factory.StartNew(() =>
{
_isAlive = true;
_executer = Task.Factory.StartNew(() => { ExecuteRandom(min, max, action); });
Thread.Sleep(minDuration);
StopExecuter();
});
}

private static void StopExecuter()
{
_isAlive = false;
_executer.Wait();

_executer.Dispose();
_executer = null;
}

private static void ExecuteRandom(int min, int max, Action action)
{
Random random = new Random();

while (_isAlive)
{
Thread.Sleep(random.Next(min, max));
action();
}
}
}

它很好用。

但是在这个例子中使用Thread.Sleep()是可以的，还是一般不使用Thread.Sleep()会发生什么并发症？有其他选择吗？

使用Thread.Sleep是否有问题？通常不会，如果您真的想挂起线程。但在这种情况下，您不希望挂起线程，而是希望挂起任务。

因此，在这种情况下，您应该使用：

1	await Task.Delay(minDuration);

这不会挂起整个线程，而是只挂起要挂起的单个任务。同一线程上的所有其他任务都可以继续运行。

相关讨论

我使用Task.Delay而不是Thread.Sleep的一个原因是，您可以将CancellationToken传递给它。如果用户想要StopExecutor，而随机接收的时间跨度很长，那么最终会阻塞很长一段时间。另一方面，在Task.Delay中，您可以取消操作，并将收到取消通知。

我认为你选择的设计还有其他问题。Random类不适合做任务调度程序。我会觉得找到一个ExecuteRandomAsync有点奇怪，因为它主要不是随机执行，而是每隔x分钟执行一些任意的Action。

相反，我会用另一种方式。同时保留已经创建的大多数内部构件，但将它们放在不同的类中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class ActionInvoker
{
private readonly Action _actionToInvoke;

public ActionInvoker(Action actionToInvoke)
{
_actionToInvoke = actionToInvoke;
_cancellationTokenSource = new CancellationTokenSource();
}

private readonly CancellationTokenSource _cancellationTokenSource;
private Task _executer;

public void Start(int min, int max, int minDuration)
{
if (_executer != null)
{
return;
}

_executer = Task.Factory.StartNew(
async () => await ExecuteRandomAsync(min, max, _actionToInvoke),
_cancellationTokenSource.Token, TaskCreationOptions.LongRunning,
TaskScheduler.Default)
.Unwrap();
}

private void Stop()
{
try
{
_cancellationTokenSource.Cancel();
}
catch (OperationCanceledException e)
{
// Log the cancellation.
}
}

private async Task ExecuteRandomAsync(int min, int max, Action action)
{
Random random = new Random();

while (!_cancellationTokenSource.IsCancellationRequested)
{
await Task.Delay(random.Next(min, max), _cancellationTokenSource.Token);
action();
}
}
}