RT-Thread Kernel Study Notes - Compreendendo threads de zumbi extintos

RT-Thread Kernel Study Notes-Kernel Object rt_object

RT-Thread Kernel Study Notes-Kernel Object Management

RT-Thread Kernel Study Notes-Kernel Object Operation API

RT-Thread kernel estudo notas - inicialização de objeto kernel organização de lista vinculada

Notas de estudo do kernel RT-Thread - compreensão aprofundada da estrutura da lista vinculada de objetos kernel

Notas de estudo do kernel RT-Thread - compreensão do modelo do dispositivo rt_device

RT-Thread Kernel Study Notes - Compreendendo threads de zumbi extintos

 

Prefácio

• No momento, todo mundo ocasionalmente discute a questão da saída do thread RT-Thread, como o thread principal, como lidar com isso após o retorno? Se recursos como RAM foram liberados.
• Recentemente, eu estava examinando o código-fonte do kernel relacionado ao thread, com base no método de gerenciamento rt_object do objeto kernel, para classificar o fluxo de processamento após a saída do thread.
• rt_thread_defunct, a estrutura de lista vinculada de threads zumbis, por que é chamada de [zumbi], o dicionário que verifiquei. Função para recuperar os recursos de memória (heap) do thread excluído.

 

Inicialização e criação de thread

• rt_thread_init: inicializa estaticamente uma thread.A estrutura da thread e pilha de thread são variáveis ​​globais. Depois de rt_thread_detach, o objeto kernel deste encadeamento é removido da lista vinculada do contêiner do kernel, [mas] a estrutura do encadeamento e a pilha do encadeamento não podem ser liberadas porque são estáticos e globais. Se você deseja inicializar e usar este encadeamento na próxima vez, você ainda pode usar a estrutura de encadeamento existente e a pilha de encadeamentos após a separação para inicialização. As características dos threads estáticos: Após a inicialização, o uso de memória não mudará.
• rt_thread_create: Crie um thread dinamicamente. Precisa habilitar: RT_USING_HEAP, gerenciamento de heap. A thread criada [Structure] e [Thread Stack] são aplicadas dinamicamente. Ao deletar este tópico, você precisa chamar rt_thread_delete. Após a exclusão, o espaço de memória (heap) ocupado pela [estrutura] e [pilha de threads] do thread pode ser liberado. Após a exclusão, este tópico não existe mais. Se você quiser começar a usá-lo novamente, será necessário recriá-lo. As características dos threads dinâmicos: Após a exclusão, os recursos de memória podem ser liberados.

 

Recuperação de recurso de thread

• RT-Thread só recupera recursos de memória de thread de rt_thread_create.
• Quando um encadeamento é inicializado estaticamente ou criado dinamicamente, ele registrará: rt_thread_exit. Depois que o encadeamento for encerrado, ele chamará rt_thread_exit.
• Em rt_thread_exit, o primeiro passo: remover o thread da lista de agendamento. Etapa 2: um thread estático chamará: rt_object_detach para remover o objeto kernel do thread do contêiner de objeto do kernel; um thread dinâmico adicionará o ponteiro da estrutura do thread (identificador de operação) à lista de threads zombie rt_thread_defunct em vez de liberá-lo imediatamente A memória ocupada por o segmento. A operação do thread zumbi é executada no thread inativo. Etapa 3: Executar agendamento de threads e alternar threads. Na execução do encadeamento ocioso, deve-se garantir que, após o encadeamento ser excluído, o encadeamento de comutação seja agendado imediatamente e a recuperação de recursos do encadeamento não precise ser de prioridade muito alta.
• No encadeamento inativo: rt_thread_idle_excute é responsável por verificar se a lista de encadeamentos zombie rt_thread_defunct está vazia e, se não estiver vazia, execute a operação de liberação de memória. Remova da lista de encadeamentos, libere a pilha de encadeamentos e libere a estrutura do kernel. Observe que apenas encadeamentos criados dinamicamente realizam esta operação.

/* 来自：rt_thread_idle_excute 片段 */

        /* remove defunct thread */
        rt_list_remove(&(thread->tlist));
        /* release thread's stack */
        RT_KERNEL_FREE(thread->stack_addr);
        /* delete thread object */
        rt_object_delete((rt_object_t)thread);

 

saídas do tópico principal

• O procedimento acima classificou a saída de threads, o fluxo de processamento de threads zumbis e a saída da thread principal. Basicamente, o fluxo também pode ser resolvido.
• Thread principal estático, não habilitado: RT_USING_HEAP, os recursos de memória não serão liberados após a saída.
• O thread principal dinâmico é habilitado: Após RT_USING_HEAP, os recursos de memória são liberados após a saída.
• Na verdade, comparando o tamanho da liberação dos recursos de memória, verifica-se que a aplicação dinâmica irá ocupar um pouco de recursos de memória extras, como 12 bytes.Esta parte será posteriormente classificada após o gerenciamento de memória.

 

Recuperação de recursos de threads dinâmicos:

Quando RT_USING_HEAP
principal existe: o tamanho da pilha de threads é 2048

msh >free
total memory: 89568
used memory : 10656
maximum allocated memory: 10656

Quando o principal não existe:

msh >free
total memory: 89568
used memory : 8456
maximum allocated memory: 10656

Pilha de thread principal, recurso após retorno: 2200 Bytesespaço

2048 栈空间 + 12Byte（rt_malloc管理占用）
128Byte rt_thread结构体大小，sizeof(struct rt_thread) + 12Byte（rt_malloc管理占用，内核对象）。

合计：2048+12+128+12 = 2200。

 

Resumindo

• Familiarizado com a inicialização, criação, separação (desinicialização), exclusão e outras operações de threads RT-Thread.
• Familiarizado com threads criados dinamicamente, após a exclusão, junte-se à lista de threads zumbis, processo de recuperação de recursos de memória.
• Compreenda o processo de saída de threads comuns, como a thread principal.

• Continue a estudar os seguintes pontos de conhecimento com perguntas:

  • Onde é executado o fluxo de trabalho do planejador? Como funciona?
  • Thread timer, cada thread irá criar um, depois que o thread é excluído, o processo de reciclagem de recursos do timer.

  rt_thread_delete /* 删除线程，如何处理定时器 */
  
  rt_timer_detach(&(thread->thread_timer)); /* 定时器资源的回收流程 */

  • Ao criar um encadeamento, mudei o nome do encadeamento (nome) para RT_NULL, ele ainda pode ser executado normalmente, mas isso tem algum efeito?
  • Na estrutura rt_thread: a lista vinculada de objetos kernel é usada para unir o contêiner de objeto kernel e o membro: o fluxo de trabalho de tlist.
  • Consideração de questões históricas: estrutura rt_thread:

  /**
  * Thread structure
  */
  struct rt_thread
  {
     /* rt object */
     char        name[RT_NAME_MAX];                      /**< the name of thread */
     rt_uint8_t  type;                                   /**< type of object */
     rt_uint8_t  flags;                                  /**< thread's flags */
  
  #ifdef RT_USING_MODULE
     void       *module_id;                              /**< id of application module */
  #endif
  
     rt_list_t   list;                                   /**< the object list */

Pode ser alterado para:

/**
 * Thread structure
 */
struct rt_thread
{
    struct rt_object parent;                            /**< inherit from rt_object */