Question

我正在构建一个服务，它将向两个外部API发出请求。结果将保留在本地数据库中。

粗略地说，该方法应该像这样工作：

#include<stdio.h>
#include<stdlib.h>

struct node {
    int data;
    struct node* next;
};

void reverse(struct node** headr) {
    struct node* current=*headr;
    struct node*temp=*headr;
    struct node* prev;
    struct node* next;

    while (current!=NULL) {
        prev=current;
        current=current->next;
        next=current;
        next->next=prev;
    }

    temp->next=NULL;
    *headr=current;
}

void push(struct node** headr, int new_data) {
    struct node* new_node = (struct node*) malloc(sizeof(struct node));

    new_node->data  = new_data;
    new_node->next = (*headr);    
    (*headr)    = new_node;
}

void print(struct node *head) {
    struct node *temp = head;
    while (temp != NULL) {
        printf("%d  ", temp->data);    
        temp = temp->next;  
    }
}

int main() {
    struct node* head = NULL;

     push(&head, 20);
     push(&head, 4);
     push(&head, 15); 
     push(&head, 85);      

     printf("Given linked list\n");
     print(head);    
     reverse(&head);                      
     printf("\nReversed Linked list \n");
     print(head);    
     getchar();
}

elixir的新手，我一直在阅读有关流程和主管的内容。我的问题是：在这里使用它们是否有意义？我可以通过在这里实现方法来使方法更快，更高性能，或者可以提高容错能力吗？

Answer 1

由于您具体询问这是否可以提高性能或容错性，我认为答案是肯定的。您可以使用Task.async并行执行请求，因为它们看起来并不相互依赖。数据库插入也是如此。我可能会在这里使用Task.Supervisor。您还可以将其配置为在发生故障时重试，只需注意不要通过确保请求和数据库插入是幂等的来重复复制。

例如，

import Supervisor.Spec 

children = [ 
  supervisor(Task.Supervisor, [[name: ExampleApp.TaskSupervisor, restart: :transient]]), 
] 

{:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)

然后，

{:ok, pid} = Task.Supervisor.start_child(ExampleApp.TaskSupervisor, fn -> 
  {:ok, response} = Service1.request(params)
  Repo.insert(response)
end)
{:ok, pid} = Task.Supervisor.start_child(ExampleApp.TaskSupervisor, fn -> 
  {:ok, response} = Service2.request(params)
  Repo.insert(response)
end)

使用elixir流程和主管改进服务方法

1 个答案: