在线程之间切换

Question

我有两个线程：

static Thread thread1 = new Thread(new ThreadStart(Team1Shots));
static Thread thread2 = new Thread(new ThreadStart(Team2Shots));

我希望线程1做一些工作（但不完成），然后让线程2做一些工作（但不完成），然后返回以完成线程1，然后返回并完成线程2。

到目前为止，我有：

static void Main(string[] args)
{
    thread1.Start();
}

private static void Team1Shots()
{
   //Do Work in here...then

   thread2.Start();
   thread2.Join(); //Go to thread2

   //When join in thread2 to here
   //Do the rest of the work

   //Get thread2 to finish
}

private static void Team2Shots()
{
   //Do Work in here...
   thread1.Join(); //Go back to thread1

   //When thread1 finishes
   //Do the rest of the work

   // Finished All work
}

这是行不通的，也不知道从这里去哪里。

Answer 1

由于您实际上从未希望并行执行任何工作，而是一次只让其中一个工作，因此您应该没有两个线程。 有一个线程可以执行所有应首先执行的操作，然后执行所有应首先执行的操作，然后执行接下来应执行的所有操作，依此类推。 通过创建多个线程来启动/停止彼此的进度，您不必要地创建工作。

Answer 2

您可以使用BlockingCollection(T)在线程之间进行通信。 将步骤建模为状态机，然后可以在线程之间进行乒乓消息处理。

// States
public enum MessageType
{
    Done,
    Work1,
    Work2,
    Work3,
    Work4
}

// Data
public class WorkerStateMessage
{
    public static readonly WorkerStateMessage Done =
        new WorkerStateMessage { Type = MessageType.Done };
    public MessageType Type { get; set; }
    public string Progress { get; set; }
    public int Data { get; set; }
}

主要

static Thread thread1 = new Thread(new ThreadStart(Team1Shots));
static Thread thread2 = new Thread(new ThreadStart(Team2Shots));
static BlockingCollection<WorkerStateMessage> thread1Messages =
    new BlockingCollection<WorkerStateMessage>();
static BlockingCollection<WorkerStateMessage> thread2Messages =
    new BlockingCollection<WorkerStateMessage>();
static BlockingCollection<WorkerStateMessage> progressMessages =
    new BlockingCollection<WorkerStateMessage>();

static void Main(string[] args)
{
    thread1Messages.Add(new WorkerStateMessage { Type = MessageType.Work1, Data = 1 });
    thread1Messages.Add(new WorkerStateMessage { Type = MessageType.Work1, Data = 2 });
    thread1Messages.Add(new WorkerStateMessage { Type = MessageType.Work1, Data = 3 });
    thread1.Start();
    thread2.Start();
    // 4 step * 3 messages = 12 progress messages
    foreach(var message in progressMessages.GetConsumingEnumerable().Take(12))
    {
        Console.WriteLine(message.Progress);
        Console.WriteLine("Current data: {0}", message.Data);
    }

    thread1Messages.Add(WorkerStateMessage.Done);
    thread2Messages.Add(WorkerStateMessage.Done);
    thread1.Join();
    thread2.Join();
}

线程1

private static void Team1Shots()
{
    foreach(var message in thread1Messages.GetConsumingEnumerable())
    {
        WorkerStateMessage nextMessage;
        switch(message.Type)
        {
            case MessageType.Work1:
                var added = message.Data + 1;
                nextMessage = new WorkerStateMessage
                {
                    Type = MessageType.Work2, 
                    Progress = "Add 1",
                    Data = added
                };
                progressMessages.Add(nextMessage);
                thread2Messages.Add(nextMessage);
            break;
            case MessageType.Work3:
                var multiplied = message.Data + 1;
                nextMessage = new WorkerStateMessage
                {
                    Type = MessageType.Work4,
                    Progress = "Multiply by 2",
                    Data = multiplied
                };
                progressMessages.Add(nextMessage);
                thread2Messages.Add(nextMessage);
            break;
            default:
                return;
        }
    }
}

线程2

private static void Team2Shots()
{
   foreach(var message in thread2Messages.GetConsumingEnumerable())
    {
        WorkerStateMessage nextMessage;
        switch(message.Type)
        {
            case MessageType.Work2:
                var added = message.Data + 2;
                nextMessage = new WorkerStateMessage
                {
                    Type = MessageType.Work3,
                    Progress = "Add 2",
                    Data = added
                };
                progressMessages.Add(nextMessage);
                thread1Messages.Add(nextMessage);
            break;
            case MessageType.Work4:
                var divided = message.Data / 2;
                nextMessage = new WorkerStateMessage 
                {
                    Type = MessageType.Work3,
                    Progress = "Divide by 2",
                    Data = divided
                };
                progressMessages.Add(nextMessage);
                thread2Messages.Add(nextMessage);
            break;
            default:
                return;
        }
    }
}

输出量

Add 1
Current data: 2
Add 1
Current data: 3
Add 1
Current data: 4
Add 2
Current data: 4
Add 2
Current data: 5
Add 2
Current data: 6
Multiply by 2
Current data: 5
Multiply by 2
Current data: 6
Multiply by 2
Current data: 7
Divide by 2
Current data: 2
Divide by 2
Current data: 3
Divide by 2
Current data: 3