Доступ к трем спискам с тремя потоками, печать элементов по порядку

Если бы это был я, я бы использовал EventWaitHandles для сигнализации и синхронизации ваших потоков. В моем коде потоки ждут сигнала, а затем распечатывают свою текущую строку, а затем снова ждут сигнала:

    static void Main(string[] args)
    {
        List<string> list1 = new List<string> { "1", "2", "3", "4" };
        List<string> list2 = new List<string> { "a", "b", "c", "d" };
        List<string> list3 = new List<string> { "*", "+", "-", "?" };


        using (EventWaitHandle waitHandle1 = new AutoResetEvent(false))
        using (EventWaitHandle waitHandle2 = new AutoResetEvent(false))
        using (EventWaitHandle waitHandle3 = new AutoResetEvent(false))
        using (EventWaitHandle waitHandle4 = new AutoResetEvent(false))
        {
            Thread t1 = new Thread(() => 
            {
                ThreadData state = new ThreadData() 
                { 
                    Name = "Thread1", 
                    Strings = list1, 
                    WaitHandle = waitHandle1, 
                    SignalHandle = waitHandle2 
                };

                PrintItemWhenSignaled(state);
            });

            Thread t2 = new Thread(() => 
            {
                ThreadData state = new ThreadData()
                {
                    Name = "Thread2",
                    Strings = list2,
                    WaitHandle = waitHandle2,
                    SignalHandle = waitHandle3
                };

                PrintItemWhenSignaled(state);
            });

            Thread t3 = new Thread(() =>
            {
                ThreadData state = new ThreadData()
                {
                    Name = "Thread3",
                    Strings = list3,
                    WaitHandle = waitHandle3,
                    SignalHandle = waitHandle4
                };

                PrintItemWhenSignaled(state);
            });


            t1.Start();
            t2.Start();
            t3.Start();

            for (int index = 0; index < list1.Count; index++)
            {
                waitHandle1.Set();
                waitHandle4.WaitOne(100);
            }
        }

        Console.WriteLine("Press any key...");
        Console.ReadKey();
    }

    private static void PrintItemWhenSignaled(ThreadData threadState)
    {
        foreach (string value in threadState.Strings)
        {
            threadState.WaitHandle.WaitOne(100);
            Console.WriteLine("{0}:{1}", threadState.Name, value);
            threadState.SignalHandle.Set();
        }
    }

    public class ThreadData
    {
        public string Name { get; set; }
        public EventWaitHandle WaitHandle { get; set; }
        public EventWaitHandle SignalHandle { get; set; }
        public List<string> Strings { get; set; }
    }
}

Хотя это очень странное требование, хороший масштабируемый способ может быть с Monitor.Pulse и Monitor.Wait

    private static readonly Object obj = new Object();
    static List<string> list1 = new List<string> { "1", "2", "3", "4" };
    static List<string> list2 = new List<string> { "a", "b", "c", "d", "e" };
    static List<string> list3 = new List<string> { "*", "+", "-", "?" };
    static int i = 0;

    //thread synchronization data
    const int numThreads = 3;
    static int workingCount = 0;
    static int lastItem = 0;
    static object locker = new object();

    static void Main(string[] args)
    {
        Thread t1 = new Thread(PrintItem);
        t1.Name = "Print1";
        Thread t2 = new Thread(PrintItem);
        t2.Name = "Print2";
        Thread t3 = new Thread(PrintItem);
        t3.Name = "Print3";
        t1.Start(0);
        t2.Start(1);
        t3.Start(2);
        t1.Join();
        t2.Join();
        t3.Join();
        Console.ReadLine();
    }

    private static void PrintItem(object state)
    {
        Interlocked.Increment(ref workingCount);
        int workingList = (int)state;
        int idx = 0;
        List<string> list = null;
        switch (workingList)
        {
            case 0:
                list = list1;
                break;
            case 1:
                list = list2;
                break;
            case 2:
                list = list3;
                break;
        }


        lock (locker)
            do
            {
                while ((lastItem % numThreads) != workingList)
                {
                    Monitor.Wait(locker);
                }

                Console.WriteLine("Thread: {0}\tValue: {1}", Thread.CurrentThread.Name, list[idx]);
                lastItem++;
                Monitor.PulseAll(locker);

            } while (++idx < list.Count);

        //Handle continuing to pulse until all lists are done.
        Interlocked.Decrement(ref workingCount);

        lock (locker)
            while (workingCount != 0)
            {
                while ((lastItem % numThreads) != workingList)
                    Monitor.Wait(locker);
                lastItem++;
                Monitor.PulseAll(locker);
            }

    }
}

из-за блокировки только один поток ... самый быстрый - первый ... может получить доступ к вашему списку.

удалите оператор блокировки или удалите:

        if (i >= list1.Count)
                break;

условие или создайте i ThreadStatic с атрибутом ThreadStatic

если это ваш ожидаемый результат?