Таймеры C # проходят в отдельном потоке?

Проходит ли System.Timers.Timer в отдельном потоке, а не в потоке, который его создал?

Допустим, у меня есть класс с таймером, который срабатывает каждые 5 секунд. Когда срабатывает таймер, в прошедшем методе изменяется какой-то объект. Допустим, изменение этого объекта занимает много времени, например 10 секунд. Возможно ли, что я столкнусь с конфликтами потоков в этом сценарии?

Для System.Timers.Timer :

См . Ответ Брайана Гидеона ниже

Для System.Threading.Timer :

В документации MSDN по таймерам говорится:

Класс System.Threading.Timer выполняет обратные вызовы в потоке ThreadPool и вообще не использует модель событий.

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

Это зависит. System.Timers.TimerИмеет два режима работы.

Если SynchronizingObjectустановлен в ISynchronizeInvokeэкземпляр, Elapsedсобытие будет выполняться в потоке, в котором размещается синхронизирующий объект. Обычно эти ISynchronizeInvokeслучаи не что иное , как обычный старый Controlи Formэкземпляры , что мы все знакомы. В этом случае Elapsedсобытие вызывается в потоке пользовательского интерфейса и ведет себя аналогично System.Windows.Forms.Timer. В противном случае это действительно зависит от конкретного ISynchronizeInvokeэкземпляра, который использовался.

Если SynchronizingObjectимеет значение null, то Elapsedсобытие вызывается в ThreadPoolпотоке и ведет себя аналогично System.Threading.Timer. Фактически, он фактически использует System.Threading.Timerскрытую информацию и выполняет операцию маршалинга после получения обратного вызова таймера, если это необходимо.

Каждое прошедшее событие будет запускаться в том же потоке, если предыдущее Elapsed еще не запущено.

Так что он обрабатывает столкновение за вас

попробуйте поместить это в консоль

static void Main(string[] args)
{
    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
    var timer = new Timer(1000);
    timer.Elapsed += timer_Elapsed;
    timer.Start();
    Console.ReadLine();
}

static void timer_Elapsed(object sender, ElapsedEventArgs e)
{
    Thread.Sleep(2000);
    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
}

вы получите что-то вроде этого

10
6
12
6
12

где 10 - вызывающий поток, а 6 и 12 запускаются из истекшего события bg. Если удалить Thread.Sleep (2000); вы получите что-то вроде этого

10
6
6
6
6

Поскольку коллизий нет.

Но это по-прежнему оставляет вам проблему. если вы запускаете событие каждые 5 секунд, а редактирование занимает 10 секунд, вам нужна блокировка, чтобы пропустить некоторые изменения.

Для System.Timers.Timer в отдельном потоке, если SynchronizingObject не установлен.

    static System.Timers.Timer DummyTimer = null;

    static void Main(string[] args)
    {
        try
        {

            Console.WriteLine("Main Thread Id: " + System.Threading.Thread.CurrentThread.ManagedThreadId);

            DummyTimer = new System.Timers.Timer(1000 * 5); // 5 sec interval
            DummyTimer.Enabled = true;
            DummyTimer.Elapsed += new System.Timers.ElapsedEventHandler(OnDummyTimerFired);
            DummyTimer.AutoReset = true;

            DummyTimer.Start();

            Console.WriteLine("Hit any key to exit");
            Console.ReadLine();
        }
        catch (Exception Ex)
        {
            Console.WriteLine(Ex.Message);
        }

        return;
    }

    static void OnDummyTimerFired(object Sender, System.Timers.ElapsedEventArgs e)
    {
        Console.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId);
        return;
    }

Вы увидите, сработал ли DummyTimer с интервалом в 5 секунд:

Main Thread Id: 9
   12
   12
   12
   12
   12
   ... 

Итак, как видно, OnDummyTimerFired выполняется в потоке Workers.

Нет, дальнейшее усложнение - если вы уменьшите интервал до 10 мс,

Main Thread Id: 9
   11
   13
   12
   22
   17
   ... 

Это связано с тем, что если предыдущее выполнение OnDummyTimerFired не было выполнено при следующем запуске тика, .NET создаст новый поток для выполнения этой работы.

Еще больше усложняя ситуацию: «Класс System.Timers.Timer обеспечивает простой способ решения этой дилеммы - он предоставляет общедоступное свойство SynchronizingObject. Установка этого свойства в экземпляр Windows Form (или элемент управления в Windows Form) гарантирует что код в вашем обработчике событий Elapsed выполняется в том же потоке, в котором был создан экземпляр SynchronizingObject ".

http://msdn.microsoft.com/en-us/magazine/cc164015.aspx#S2

Если прошедшее событие занимает больше времени, чем интервал, он создаст еще один поток, чтобы вызвать истекшее событие. Но для этого есть обходной путь

static void timer_Elapsed(object sender, ElapsedEventArgs e)    
{     
   try
   {
      timer.Stop(); 
      Thread.Sleep(2000);        
      Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);    
   }
   finally
   {
     timer.Start();
   }
}