Architecture 文件异步到达的相关数据处理管道

我有几个与数据相关的任务/管道，其中一些任务/管道依赖于另一个任务/管道的完成。更困难的是，数据可以异步到达，这意味着某些任务需要等待，直到上一步中的所有文件或任务都已处理完毕

以下是一个例子：

假设我们有一个原始文件

x[i，j]

，其中

i

代表主类别

j

中的一个特定子类别

我需要运行以下管道：

管道1：清理原始文件

x[i，j]

并将其存储为

x\u clean[i，j]

管道2：一旦管道1为

i

中的所有

j

完成后，聚合

x_clean[i，j]

的结果，并将其存储为

y_clean[j]

管道3：清理原始文件

z[j]

并将其存储为

z\u clean[j]

管道4：管道2和管道3完成后，将

z_-clean[j]

和

y_-clean[j]

组合起来，并将其存储为

w_-clean[j]

---

我可以应用什么样的模型来处理这种数据流方法？这种数据处理任务背后有什么方法吗？GCP是否有针对此类问题的解决方案？

在生产过程中

• 步骤取决于其他步骤的完成情况

• 物料可以异步到达，这意味着后续步骤将等待产品到达以继续工作。然而，请注意，这并不意味着无限量的材料可以到达失控，只有材料将消耗的具体生产订单。如果您的场景允许无限量的数据流涌入，那么您必须在预处理之前对其进行组织，以避免混合不同的产品组件。不要试图在某个缓冲区或其他地方处理异步到达的数据，因为制造数据产品涉及的是关系数据，而不是原材料

• 子组件可以在连接分支中完成，这意味着组装步骤将在组装开始之前等待相关组件的协调集合到达

我是POWER的创建者，POWER是迄今为止唯一的协作（制造）体系结构。关于这个主题，有很多东西需要学习，但是你可以在网上找到我的文章和代码：

以下是制造业工作模型中的流程：

    class MyProduct
    {
        public object[i,j] x_clean { get; set; }
        public object[j] y_clean { get; set; }
        public object[j] z_clean { get; set; }
        // final product
        public object[j] w_clean { get; set; }
    }
    class MyProcess : Producer<MyProduct>, IProcess, IMachine, IOrganize
    {
        // process inputs
        public object[i,j] x { get; set; }  // raw file
        public object[j] z { get; set; } // raw file

        // machines
        public CleanerA Cleaner1 { get; set; }
        public Aggregator Aggregator1 { get; set }
        public CleanerB Cleaner2 { get; set; }
        public Assembler Assembler1 { get; set; }

        public void D() { // instantiates properties and machines }
        public void O()
        {
            // bind machines to work on the same data points
            // allows maintenance to later remove cleaners if it becomes possible
            // for the process to receive data in the correct form
            Cleaner1.x = x;
            Cleaner1.Product.x_clean = Product.x_clean;

            Aggregator1.x_clean = Product.x_clean;
            Aggregator1.Product.y_clean = Product.y_clean;

            Cleaner2.z = z;
            Cleaner2.Product.z_clean = Product.z_clean;

            Assembler1.z_clean = Product.z_clean;
            Assembler1.y_clean = Product.y_clean;
            Assembler1.Product.w_clean = Product.w_clean;
        }

        // hardcoded synchronous controller
        public void M()
        {
            Cleaner1.M();
            Aggregator1.M();
            Cleaner2.M();
            Assembler1.M();
        }
    }

    // these class pairs are Custom Machines, very specific work organized
    // by user requirements rather than in terms of domain-specific operations
    class CleanerAProduct
    {
        public object[i,j] x_clean { get; set; }
    }
    class CleanerA: Producer<CleanerAProduct>, IMachine
    {
        public object[i,j] x { get; set; }  // raw file
        public void M()
        {
            // clean the raw file x[i,j] and store it as x_clean[i,j]
        }
    }


    class AggregatorProduct
    {
        public object[j] y_clean { get; set; }
    }
    class Aggregator: Producer<AggregatorProduct>, IMachine
    {
        public object[i,j] x_clean { get; set; }
        public void M()
        {
            // aggregate the results from x_clean[i,j] and store it as y_clean[j]
        }
    }


    class CleanerBProduct
    {
        public object[j] z_clean { get; set; }
    }
    class CleanerB : Producer<CleanerBProduct>, IMachine
    {
        public object[j] z { get; set; }
        public void M()
        {
            // clean a raw file z[j] and store it as z_clean[j]
        }
    }


    class AssemblerProduct
    {
        public object[j] w_clean { get; set; }
    }
    class Assembler : Producer<AssemblerProduct>, IMachine
    {
        public object[j] y_clean { get; set; }
        public object[j] z_clean { get; set; }
        public void M()
        {
            // combine z_clean[j] and y_clean[j] and store it as w_clean[j]
        }
    }

类MyProduct
{
公共对象[i，j]x_clean{get；set；}
公共对象[j]y_clean{get；set；}
公共对象[j]z_clean{get；set；}
//最终产品
公共对象[j]w_clean{get；set；}
}
类MyProcess:Producer、IProcess、IMachine、IOrganize
{
//过程输入
公共对象[i，j]x{get；set；}//原始文件
公共对象[j]z{get；set；}//原始文件
//机器
public CleanerA Cleaner1{get；set；}
公共聚合器聚合器1{get；set}
公共CleanerB Cleaner2{get；set；}
公共汇编程序汇编程序1{get；set；}
public void D（）{//实例化属性和计算机}
公共图书馆（
{
//绑定机器以在相同的数据点上工作
//允许维护人员在可能的情况下移除清洁剂
//用于流程以正确的形式接收数据
清洁剂1.x=x；
Cleaner1.Product.x_clean=Product.x_clean；
聚合器1.x_clean=Product.x_clean；
聚合器1.Product.y_clean=Product.y_clean；
清洁剂2.z=z；
Cleaner2.Product.z_clean=Product.z_clean；
Assembler1.z_clean=Product.z_clean；
Assembler1.y_clean=Product.y_clean；
Assembler1.Product.w_clean=Product.w_clean；
}
//硬编码同步控制器
公屋
{
Cleaner1.M（）；
Aggregator1.M（）；
Cleaner2.M（）；
汇编程序1.M（）；
}
}
//这些类对是定制的机器，组织了非常具体的工作
//根据用户需求，而不是特定于领域的操作
类清洁剂产品
{
公共对象[i，j]x_clean{get；set；}
}
CleanerA类：制作人、IMachine
{
公共对象[i，j]x{get；set；}//原始文件
公屋
{
//清理原始文件x[i，j]并将其存储为x_clean[i，j]
}
}
类聚合产品
{
公共对象[j]y_clean{get；set；}
}
类聚合器：生产者，IMachine
{
公共对象[i，j]x_clean{get；set；}
公屋
{
//将x_clean[i，j]的结果汇总并存储为y_clean[j]
}
}
类清洁剂产品
{
公共对象[j]z_clean{get；set；}
}
清洁工人B类：生产商，IMachine
{
公共对象[j]z{get；set；}
公屋
{
//清理原始文件z[j]并将其存储为z_clean[j]
}
}
类汇编产品
{
公共对象[j]w_clean{get；set；}
}
类汇编程序：Producer，IMachine
{
公共对象[j]y_clean{get；set；}
公共对象[j]z_clean{get；set；}
公屋
{
//将z_-clean[j]和y_-clean[j]组合起来，并以w_-clean[j]的形式存储
}
}

生产过程类的正常使用：

实例化。调用D（）来实例化机器和产品

为流程分配任何输入

调用O（），让流程将这些输入分配给机器，并绑定机器以对最终产品进行操作。这是你最后一次有机会在开始之前覆盖这些任务