C# 在线程之间切换

我有两条线索：

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

我希望thread1做一些工作（但不完整），然后thread2做一些工作（但不完整），然后返回完成thread1，然后返回并完成thread2

到目前为止，我有：

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
}

---

这不起作用，也不知道从这里走到哪里。

因为你从来都不想让任何工作并行完成，而是一次只让其中一个工作，所以你不应该有两个线程。让一个线程先完成所有应该做的事情，然后再完成所有应该做的事情，然后再完成所有下一步应该做的事情，依此类推。您通过创建多个线程来启动/停止彼此的进程，这是不必要的创建工作。

您可以使用a在线程之间进行通信。将这些步骤建模为状态机，您可以在线程之间乒乓消息

// 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; }
}

主要

线程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

---

您应该使用信号量或互斥量来同步多个线程

Thread.Join

不进行切换（它将此线程连接到现有线程，阻塞直到完成）。您也可以使用ManualResetEvent或critical Section（锁），根据您需要执行的操作，有很多选项。顺便说一下，根据注释，您已经描述了一种不可能的情况。线程1启动线程2，等待一段时间，然后线程2“切换”回线程1，执行更多的工作，然后在线程2上等待，但线程2正在线程1上等待。它的编码方式是死锁，描述它的方式是活锁。

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