Implementing a Scheduler(something that implements a given schedule)
Your code is super-comlicated for such simple logic. I'm also pretty sure it deadlocks in pretty much any use case.

class Scheduler : IDisposable
{
    private readonly object scheduleLock = new object();
    private int[] schedule = null;
    private int scheduleIndex = 0;
    private readonly ManualResetEvent collectionResetEvent = new ManualResetEvent(false);
    private readonly AutoResetEvent delayEvent = new AutoResetEvent(false);
    private volatile bool working;

    private Thread th;

    public Dispose()
    {
        Offline();
    }

    public void RunSchedule() 
    {
        while (true)
        {
            collectionResetEvent.WaitOne();
            if (!working) return;

            lock (scheduleLock)
            {
               if (schedule == null || scheduleIndex &gt;= shedule.Count) 
               {
                   collectionResetEvent.Reset();
                   if (!working) return;
               }
               else
               {
                   var nextSchedule = schedule[scheduleIndex++];
                   //execute, 
                   //probably can be done outside the lock
               }
            }

            delayEvent.WaitOne(120 * 1000);
        }
    }

    public void Offline() 
    {
        if (!working) return;
        working = false;
        delayEvent.Set();
        collectionResetEvent.Set();
        th.Join();
        th = null;
    }

    public void Online() 
    {
        if (working) return;
        working = true;
        th = new Thread(RunSchedule);
        th.Start();
    }

    public void OfflineTooLong() 
    {
        ScheduleReady(null);
    }

    public void ScheduleReady(int[] schedule) 
    {
        lock (scheduleLock) 
        {
            schedule = schedule;
            scheduleIndex = 0;
            collectionResetEvent.Set();
            delayEvent.Set();
        }
    }
}


This is just an example of how it can be refactored, to give you an idea. It can still potentially deadlock (for example if you call offline and dispose at the same time from different threads) so it requires some tweaking depending on your requirements. RunSchedule() method is somewhat hard to read, it should be splitted into sub-methods. BartoszKP makes a perfectly valid points as well, check his answer, if you haven't already.