C# 我想运行下一个工作时，几个工作是在同一时间运行完成

我想运行下一个工作时，几个工作是在同一时间运行完成

我不能期望工作按顺序完成

WorkA, WorkB, WorkC is running at the same time at different threads

每项工作完成后 运行

代码管理器.SetWorkState（Manager.WorkState）

Ex : WorkA is done
Manager.SetWorkState(Manager.WorkState) Manager.SetWorkState(Manager.WorkState.WorkAIsDone); 

class Manager
{

    public enum WorkState
    {
        WorkAIsDone = 0x1,
        WorkBIsDone = 0x2,
        WorkCIsDone = 0x4,
    }

        WorkState state;

    public void SetWorkState(WorkState newState)
    {
        state = state | newState;
        if (state == (WorkState.WorkAIsDone | WorkState.WorkBIsDone | WorkState.WorkCIsDone))
        {
            Run_NextWork();
        }
    }

    public void Run_NextWork() { ... }
}

是否有更有效的解决方案

---

对于这种情况，您的解决方案是什么？

有一个简单的解决方案，使用。 下面是一些

伪代码

，但我希望你能理解

class Manager
{
    List<Task> _tasks;

    public Manager()
    {

        _tasks = new List<Task>();

        //assuming your 3 tasks are already started from somewhere, run fourth task 
        StartNewTask(Run_NextWork);
    }

    public void StartNewTask(Action action)
    {
        //WaitAll waits for all tasks in array to complete before continuing
        Task.WaitAll(_tasks.ToArray());
        var newTask = Task.Run(action);
    }

    public void Run_NextWork()
    {
    }
}

类管理器
{
列出任务；
公共经理（）
{
_任务=新列表（）；
//假设您的3个任务已经从某个地方开始，运行第四个任务
启动新任务（运行下一个网络）；
}
公共作废开始任务（操作）
{
//WaitAll等待数组中的所有任务完成，然后继续
Task.WaitAll（_tasks.ToArray（））；
var newTask=Task.Run（action）；
}
公共无效运行_NextWork（）
{
}
}

有一个简单的解决方案，使用。 下面是一些

伪代码

，但我希望你能理解

class Manager
{
    List<Task> _tasks;

    public Manager()
    {

        _tasks = new List<Task>();

        //assuming your 3 tasks are already started from somewhere, run fourth task 
        StartNewTask(Run_NextWork);
    }

    public void StartNewTask(Action action)
    {
        //WaitAll waits for all tasks in array to complete before continuing
        Task.WaitAll(_tasks.ToArray());
        var newTask = Task.Run(action);
    }

    public void Run_NextWork()
    {
    }
}

类管理器
{
列出任务；
公共经理（）
{
_任务=新列表（）；
//假设您的3个任务已经从某个地方开始，运行第四个任务
启动新任务（运行下一个网络）；
}
公共作废开始任务（操作）
{
//WaitAll等待数组中的所有任务完成，然后继续
Task.WaitAll（_tasks.ToArray（））；
var newTask=Task.Run（action）；
}
公共无效运行_NextWork（）
{
}
}

有一个简单的解决方案，使用。 下面是一些

伪代码

，但我希望你能理解

class Manager
{
    List<Task> _tasks;

    public Manager()
    {

        _tasks = new List<Task>();

        //assuming your 3 tasks are already started from somewhere, run fourth task 
        StartNewTask(Run_NextWork);
    }

    public void StartNewTask(Action action)
    {
        //WaitAll waits for all tasks in array to complete before continuing
        Task.WaitAll(_tasks.ToArray());
        var newTask = Task.Run(action);
    }

    public void Run_NextWork()
    {
    }
}

类管理器
{
列出任务；
公共经理（）
{
_任务=新列表（）；
//假设您的3个任务已经从某个地方开始，运行第四个任务
启动新任务（运行下一个网络）；
}
公共作废开始任务（操作）
{
//WaitAll等待数组中的所有任务完成，然后继续
Task.WaitAll（_tasks.ToArray（））；
var newTask=Task.Run（action）；
}
公共无效运行_NextWork（）
{
}
}

有一个简单的解决方案，使用。 下面是一些

伪代码

，但我希望你能理解

class Manager
{
    List<Task> _tasks;

    public Manager()
    {

        _tasks = new List<Task>();

        //assuming your 3 tasks are already started from somewhere, run fourth task 
        StartNewTask(Run_NextWork);
    }

    public void StartNewTask(Action action)
    {
        //WaitAll waits for all tasks in array to complete before continuing
        Task.WaitAll(_tasks.ToArray());
        var newTask = Task.Run(action);
    }

    public void Run_NextWork()
    {
    }
}

类管理器
{
列出任务；
公共经理（）
{
_任务=新列表（）；
//假设您的3个任务已经从某个地方开始，运行第四个任务
启动新任务（运行下一个网络）；
}
公共作废开始任务（操作）
{
//WaitAll等待数组中的所有任务完成，然后继续
Task.WaitAll（_tasks.ToArray（））；
var newTask=Task.Run（action）；
}
公共无效运行_NextWork（）
{
}
}

所以你想在A、B和C完成后发生什么？这不是效率低下，只需要几纳秒。专注于编写正确的代码，

state=newState | newState是胡说八道。谢谢你的问题中没有足够的信息。首先，如果“工作”可以异步完成，那么就存在线程安全问题，因为两个线程可能同时调用
SetWorkState（）
，导致无法设置标志位。此外，尚不清楚工作是如何进行的。你说每个“工作”项都在不同的线程中，但是你如何实现这一点呢。到目前为止，建议的一个答案似乎很有用……如果您认为没有，您需要解释如何在各个线程中运行“工作”，但没有明显的方法来确定它们的完成情况。谢谢您的回答。存在线程安全问题。我得用锁把它锁好。而工作就是请求和响应。工人正在向服务器发送请求。收到响应时发生事件。在处理响应之后，工作就完成了。所以你想在A、B和C完成后发生什么事情吗？这不是低效的，只需要几纳秒。专注于编写正确的代码，
state=newState | newState是胡说八道。谢谢你的问题中没有足够的信息。首先，如果“工作”可以异步完成，那么就存在线程安全问题，因为两个线程可能同时调用
SetWorkState（）
，导致无法设置标志位。此外，尚不清楚工作是如何进行的。你说每个“工作”项都在不同的线程中，但是你如何实现这一点呢。到目前为止，建议的一个答案似乎很有用……如果您认为没有，您需要解释如何在各个线程中运行“工作”，但没有明显的方法来确定它们的完成情况。谢谢您的回答。存在线程安全问题。我得用锁把它锁好。而工作就是请求和响应。工人正在向服务器发送请求。收到响应时发生事件。在处理响应之后，工作就完成了。所以你想在A、B和C完成后发生什么事情吗？这不是低效的，只需要几纳秒。专注于编写正确的代码，
state=newState | newState是胡说八道。谢谢你的问题中没有足够的信息。首先，如果“工作”可以异步完成，那么就存在线程安全问题，因为两个线程可能同时调用
SetWorkState（）
，导致无法设置标志位。此外，尚不清楚工作是如何进行的。你说每个“工作”项都在不同的线程中，但是你如何实现这一点呢。到目前为止，建议的一个答案似乎很有用……如果您认为没有，您需要解释如何在各个线程中运行“工作”，但没有明显的方法来确定它们的完成情况。谢谢您的回答。存在线程安全问题。我得用锁把它锁好。而工作就是请求和响应。工人正在向服务器发送请求。A.