LSW::v4::CustomThread

LSW::v4::CustomThread

---

	Valores
Arquivo	"Templates/templates.h"
Tipo	semi-dependente
Dependências	Abort

---

O que é?

Para facilitar bastante a vida ao redor do programa e outros cantos do app, CustomThread foi criado. Com qualquer tipo como retorno (menos void, ele não gosta de void atualmente, talvez use void* e retorne nullptr?) é possível criar threads em cima do std::thread ou ALLEGRO_THREAD.

---

Como funciona?

Existe duas maneiras de usar o CustomThread: ou você usa std::thread (padrão), ou usa ALLEGRO_THREAD (coloque em cima do seu código um #define LSW_THREAD_ALLEGRO.

• std::thread: É o padrão da biblioteca STD, usado independentemente do Allegro. Se quiser o caminho padrão, use ele.
• ALLEGRO_THREAD: É a parte do Allegro que cuida de multithread. Ela não é simplesmente um std::thread no fundo, bem que suporta (na teoria) coisas como matar a thread mesmo se ela não quiser terminar (kill() com std::thread faz o programa dar um erro absurdo).

Para pegar o resultado do lambda que você passa pro CustomThread você precisa terminar com join() e depois pegar o valor com result(). Terminar com kill() tem resultado imprevisível, e é garantido erro fatal com std::thread.

---

A classe:

A classe basicamente se resume a essas funções:

void CustomThread::CustomThread(const std::function<T(std::function<bool(void)>)>);
void CustomThread::setFunc(const std::function<T(std::function<bool(void)>)>);
void CustomThread::start();
void CustomThread::stop();
void CustomThread::join();
void CustomThread::kill();
T CustomThread::result();

• CustomThread(...): (construtor) prepara uma thread com o lambda (função) que você definiu. OBS: seu lambda precisa receber um lambda que te retorna verdadeiro se o seu loop deve continuar rodando, ou seja, faça seu while em cima do std::function<bool(void)> que é passado para seu lambda.
• setFunc(...): igual ao construtor acima.
• start(): inicia a thread que acabou de definir.
• stop(): avisa a thread (pelo lambda) que deve terminar.
• join(): espera a thread terminar e desfaz a thread.
• kill(): força o término da thread (se estiver rodando, não recomendado) e limpa os ponteiros.
• result(): pega o último retorno do lambda que você definiu (dê return no final do seu lambda e pegue o valor aqui).

---

Exemplos de uso:

Esse exemplo de código cria um CustomThread com uma função que acorda, fica avisando que está rodando e depois termina com um valor aleatório. Logo em seguida ele mostra o valor fora da thread, confirmando seu funcionamento com sucesso.

#define _CRT_RAND_S  
#define LSW_THREAD_ALLEGRO

#include "..\LSW\Templates\templates.h" // o seu caminho pode mudar
#include <functional>
#include <thread>
#include <stdlib.h>

int main() {
  CustomThread<unsigned> ctrl([](std::function<bool(void)> is_running) {
    unsigned ret;
    printf_s("Blah blah init lmao\n");
    while (is_running()) {
      printf_s("Still running!\n");
      al_rest(1.0);
    }
    printf_s("I'm dead lmao\n");
    rand_s(&ret);
    printf_s("Returning the awesome value of %u\n", ret);
    return ret;
  });

  ctrl.start();

  al_rest(5.0);

  ctrl.join();

  printf_s("Return value: %u", ctrl.result());

  return 0;
}

Esse é o resultado esperado no console, única coisa variando é o valor aleatório:

Blah blah init lmao
Still running!
Still running!
Still running!
Still running!
Still running!
I'm dead lmao
Returning the awesome value of 4286028110
Return value: 4286028110