C# 确定线程已运行多长时间

我需要一个逻辑，当一个线程运行超过X秒时，它允许我做一些事情

就像在这个极其丑陋的例子中一样，这里它将每秒检查一次，如果

workerThread

运行10分钟或更长时间，它将显示一条消息

var timeWorking = TimeSpan.FromMinutes(0);
workerThread = new Thread(RunTask);
workerThread.Start(task);
while (workerThread.IsAlive)
{
    Thread.Sleep(TimeSpan.FromSeconds(1));
    timeWorking = timeWorking.Add(TimeSpan.FromSeconds(1));
    if (timeWorking.TotalMinutes < 10) continue;
    timeWorking = TimeSpan.FromMinutes(0);
    Console.Writeline("Here we go... the event")
}

var timeWorking=TimeSpan.frommins（0）；
workerThread=新线程（RunTask）；
workerThread.Start（任务）；
while（workerThread.IsAlive）
{
线程睡眠（TimeSpan.FromSeconds（1））；
timeWorking=timeWorking.Add（TimeSpan.FromSeconds（1））；
如果（timeWorking.TotalMinutes<10）继续；
timeWorking=TimeSpan.FromMinutes（0）；
Console.Writeline（“我们开始……事件”）
}

请帮我纠正一下。。。 我应该使用什么

Diagnostics.StopWatch

，

System.Timers.Timer

或

Threading.Timer

UPD：所有的答案让我更加困惑

任务是检查

workerThread

是否运行超过X个时间量，如果是，则调用某个方法，重置计时器，然后再次检查自上次调用该方法以来

workerThread

现在是否运行超过X个时间量。。。等等

UPD2：基本上我有一个线程，它根据从AmazonSQS队列中提取的信息进行处理。SQS队列消息具有可见性超时。如果任务将花费比默认可见性超时更长的时间，则消息将在任务完成之前返回队列。然后它将被另一台机器拾取。为了避免这种情况，我需要延长SQS消息的可见性超时。 因此，我可以通过定期检查线程是否仍然处于活动状态来做到这一点，然后我可以为消息可见性超时添加几分钟。大约一分五十秒后，我应该再次检查，如果线程仍然

是活动的

，那么再增加几分钟，依此类推。

根据您所描述的，我认为更适合。但是，这要视情况而定。如果您想使用计时器对UI执行某些操作。形式。计时器更好

在这两种情况下，您都可以简单地检查计时器运行（或勾选）时线程是否仍然处于活动状态，如果仍然处于活动状态，则执行一些操作

e、 g

这将在1秒后检查线程状态。如果它还活着，那么它至少已经运行了一秒钟

这样做的好处是不阻塞任何线程。如果你有一个UI，并且你想这样做，那么你就不能阻止UI线程（它将变得无响应，并提供糟糕的用户体验）。

根据你的描述，我认为它更适合。但是，这要视情况而定。如果您想使用计时器对UI执行某些操作。形式。计时器更好

在这两种情况下，您都可以简单地检查计时器运行（或勾选）时线程是否仍然处于活动状态，如果仍然处于活动状态，则执行一些操作

e、 g

这将在1秒后检查线程状态。如果它还活着，那么它至少已经运行了一秒钟

---

这样做的好处是不阻塞任何线程。如果您有一个UI，并且希望执行此操作，则不能阻止UI线程（它将变得无响应，并提供较差的用户体验）。

您可以使用计时器，一旦触发经过的时间，它将引发事件

 private static void Main(string[] args)
    {
        var thread = new Thread(
            () =>
                {
                    var timer = new System.Timers.Timer
                        {
                            Interval = 10000, //10s
                            AutoReset = false, //only raise the elapsed event once
                        };
                    timer.Elapsed += timer_Elapsed;
                    timer.Start();
                    while (true)
                    {
                        Console.WriteLine("Running...");
                        Thread.Sleep(1000); //Always put a thread to sleep when its blocking so it does not waste CPU cycles.
                    }
                });
        thread.Start();
    }

    private static void timer_Elapsed(object sender, ElapsedEventArgs e)
    {
        //thread is running for more that X (10s) amount of seconds
        Console.WriteLine("Timer elapsed");
    }

这是一个简单的例子。在本例中，线程从不退出。但是你可以在必要的地方添加你自己的逻辑，以获得你想要实现的目标

---

简短回答：是的，使用System.Timers.Timer

您可以使用一个计时器，一旦触发经过的时间，它将引发事件

 private static void Main(string[] args)
    {
        var thread = new Thread(
            () =>
                {
                    var timer = new System.Timers.Timer
                        {
                            Interval = 10000, //10s
                            AutoReset = false, //only raise the elapsed event once
                        };
                    timer.Elapsed += timer_Elapsed;
                    timer.Start();
                    while (true)
                    {
                        Console.WriteLine("Running...");
                        Thread.Sleep(1000); //Always put a thread to sleep when its blocking so it does not waste CPU cycles.
                    }
                });
        thread.Start();
    }

    private static void timer_Elapsed(object sender, ElapsedEventArgs e)
    {
        //thread is running for more that X (10s) amount of seconds
        Console.WriteLine("Timer elapsed");
    }

这是一个简单的例子。在本例中，线程从不退出。但是你可以在必要的地方添加你自己的逻辑，以获得你想要实现的目标

---

简短回答：是的，使用System.Timers.Timer

既然您知道线程需要在十分钟后执行某些操作，为什么不简单地在计时器上使用如下间隔：

var interval = 1000 * 60 * 10; // ten minutes
var timer = new System.Timers.Timer(interval) { AutoReset = false };
timer.Elapsed += ((sender, eventArgs) =>
    {
        // Do your work here...
    });

workerThread = new Thread(RunTask);
workerThread.Start(task);
timer.Start();

---

这样，您就不必每秒钟检查一次，而是在所需的时间后执行代码。

既然您知道线程需要在十分钟后执行某些操作，为什么不简单地在计时器上使用如下间隔：

var interval = 1000 * 60 * 10; // ten minutes
var timer = new System.Timers.Timer(interval) { AutoReset = false };
timer.Elapsed += ((sender, eventArgs) =>
    {
        // Do your work here...
    });

workerThread = new Thread(RunTask);
workerThread.Start(task);
timer.Start();

---

这样，您就不必每秒钟检查一次，您将在所需的时间后执行代码。

例如，您可以使用任务等待方法

var t = Task.Factory.StartNew(() => MyAction()); // MyAction is an action to be executed in parallel


bool check = t.Wait(10000); //wait for 10000 milliseconds
if (check)
{
 // all ok
}
else 
{
  // over time 
}

---

等待方法会一直阻塞，直到任务结束或超时。如果不想阻止主线程，可以使用另一个并行工作的任务运行示例代码并检查工作任务。

例如，可以使用任务等待方法

var t = Task.Factory.StartNew(() => MyAction()); // MyAction is an action to be executed in parallel


bool check = t.Wait(10000); //wait for 10000 milliseconds
if (check)
{
 // all ok
}
else 
{
  // over time 
}

---

等待方法会一直阻塞，直到任务结束或超时。如果您不想阻止主线程，可以使用另一个并行工作的任务运行示例代码并检查工作任务。

您也可以执行

线程。使用
时间跨度加入
，如处的示例，这样您就不必执行
线程。睡眠

注意：这两种方法都会阻止调用线程，直到时间过去。不适用于主/用户界面线程
 您也可以执行
线程。使用
时间跨度加入
，如中的示例，这样您就不必执行
线程。睡眠

注意：这两种方法都会阻止调用线程，直到时间过去。不适用于主/用户界面线程
 您希望线程使用CPU的时间（计划执行）还是当前示例中的运行时间？旁注：期望睡眠提供精确的延迟是错误的假设-睡眠的唯一保证是线程不会在请求的时间之前被唤醒，它可能会睡得更长-因此在“时间工作”中添加秒将始终小于实际运行时间。您希望线程使用CPU的时间（计划执行）还是当前示例中的运行时间？旁注：期望睡眠提供精确的延迟是错误的假设-睡眠的唯一保证是线程不会被唤醒