Programa com POSIX Threads

[Juliano Rossi]

E ai galera... sou novo aqui e com programação em C++.

Gostaria de uma ajuda de vocês sobre um teste que estou fazendo.

O problema é o seguinte:

Quando executo ou debugo meu prog ele fica não trava, mas pára de executar sem terminar o processo.

Obrigado desde já.

Seguem os códigos:

CriarThread.cpp:

#include <pthread.h> 
#include <sched.h>
#include <stdio.h>
#include <stdiostream.h>
#include <iostream>
#include <stdlib.h>
#include <cstdlib>
#include <iostream>
#include <sys/types.h>
#include <process.h>
#include <string.h>

#include "CriarThread.h"

pthread_mutex_t myMutex;
pthread_attr_t myAttr;

/*----------Cria o ID da Thread de forma global----------*/
pthread_t t1;

using namespace std;

void *ExecutaAcao(void *ptr);

/*----------Construtores----------*/
CriarThread::CriarThread() {
    // TODO Auto-generated constructor stub
}

/*----------Destrutores----------*/
CriarThread::~CriarThread() {
    // TODO Auto-generated destructor stub
}

/*----------Cria um nova Thread----------*/
void CriarThread::NovaThread(){
    
    int result=0;
    char *msg;
    msg = "Thread ";

    result = pthread_create(&t1, &myAttr, ExecutaAcao, (void *) msg);
    
    if (result){
        printf("ERRO:\nCódigo retornado na criação da PThread = %d", result);
        exit(-1);
    }    
}

/*----------Cria o Atributo da nova Thread----------*/
void CriarThread::CriaAtributo(){
    
    /*----------Declaração de Variáveis----------*/
    
    int prio;
    printf("Digite a prioridade da Thread:");
    prio = getchar();
    char *tipoSched;
    printf("Digite o tipo de escalonamento:\n(FIFO, ROUND-ROBIN, OTHER, SPORADIC)\n");
    strupr(gets(tipoSched));
    char *estado;
    printf("Digite seu estado de execucao:\n(SEPARADA ou UNIDA)\n");
    strupr(gets(estado));
    char *escopo;
    printf("Digite o escopo de processamento da mesma:\n(SISTEMA ou PROCESSO)\n");
    strupr(gets(escopo));
    
    /*----------Inicia a estrutura do atributo----------*/
    pthread_attr_init(&myAttr);

    /*    Altera o estado para "separado"; 
     *    torna a execução da Thread independente ou não das outras
     */ 
    if (stricmp(estado, (char *)"SEPARADA"))
        pthread_attr_setdetachstate(&myAttr, PTHREAD_CREATE_DETACHED);
    else if (stricmp(estado, (char *)"UNIDA"))
        pthread_attr_setdetachstate(&myAttr, PTHREAD_CREATE_JOINABLE);

    
    /*----------Altera o escopo de execução da Thread----------*/
    
    /*    .1 - Escopo SISTEMA = As threads competem pelo tempo de processamento
     *          conforme a divisão do sistema operacional.
     */    
    if (stricmp(escopo, (char *)"SISTEMA"))
        pthread_attr_setscope(&myAttr, PTHREAD_SCOPE_SYSTEM);
    
    /*    .2 - Escopo PROCESSO = As threads competem internamente 
     *          dentro do tempo que o processo que as criou possui.
     */
    else if (stricmp(escopo, (char *)"PROCESSO"))
        pthread_attr_setscope(&myAttr, PTHREAD_SCOPE_PROCESS);

    /*    Sobrescreve o valor padrão da opção INHERITED_SCHED (define se thread 
     *     recém-criada herdará os parâmetros e políticas de thread criadora).
     *  A macro PTHREAD_EXPLICIT_SCHED define que a nova pthread 
     *     deverá usar os valores da variável atributo.
     */
    pthread_attr_setinheritsched(&myAttr, PTHREAD_EXPLICIT_SCHED);
    
    
    /*----------Define a política de escalonamento da Thread----------*/    

    /*    .1 - A primeira política, a First-in First-out (SCHED_FIFO), 
     *           leva o escalonador ao comportamento de quem chegar primeiro.
     *          Caso possuam a mesma prioridade, a que chegou primeiro na fila 
     *          de escalonamento conseguirá utilizar o espaço de memória. 
     *          Caso as duas threads possuam prioridades distintas, a de maior 
     *          valor vencerá a disputa.
     */
    if (stricmp(tipoSched, (char *)"FIFO"))
        pthread_attr_setschedpolicy(&myAttr, SCHED_FIFO);
    
    /*    .2 - Na segunda política, Round-Robin (SCHED_RR), as threads de igual 
     *          prioridade serão escalonadas conforme as frações de tempo para cada 
     *          processo em partes iguais e de forma circular, sem manipulação de 
     *          todos os processos, podendo algumas delas sofrer por preempções.
     */    
    else if (stricmp(tipoSched, (char *)"ROUND-ROBIN"))
        pthread_attr_setschedpolicy(&myAttr, SCHED_RR);
        
    /*    .3 - A terceira política, definida pela macro SCHED_OTHER, 
     *          é usada para sinalizar que as threads não mais precisam de uma 
     *          política específica de escalonamento.
     */
    else if (stricmp(tipoSched, (char *)"OTHER"))
        pthread_attr_setschedpolicy(&myAttr, SCHED_RR);
    
    /*    .4 - Na quarta, SCHED_SPORADIC, os processos são ativados irregularmente, 
     *          porém com um intervalo mínimo entre duas invocações consecutivas 
     *          do mesmo processo; implementação do servidor esporádico usada para 
     *          executar processos aperiódicos.
     */
    else if (stricmp(tipoSched, (char *)"SPORADIC"))
        pthread_attr_setschedpolicy(&myAttr, SCHED_SPORADIC);

    /*----------Define o nível de prioridade----------*/
    myAttr.param.sched_priority = prio;

}

void CriarThread::AguardaFimThread(){
    pthread_join(t1, NULL);
}

void CriarThread::FinalizaThread(){
    pthread_exit(NULL);
}

void CriarThread::AlocaMemoria(){
    pthread_mutex_lock(&myMutex);
}

void CriarThread::LiberaMemoria(){
    pthread_mutex_unlock(&myMutex);
}

void *ExecutaAcao(void *ptr){

    char *msg;
    msg = (char *) ptr;
    for(int i = 0; i < 10000;i++){
        cout <<" #" << i << endl;    
    }
}

CriarThread.h:

#ifndef CRIARTHREAD_H_
#define CRIARTHREAD_H_

class CriarThread {
public:
    CriarThread();
    virtual ~CriarThread();
    void NovaThread();
    void AguardaFimThread();
    void FinalizaThread();
    void AlocaMemoria();
    void LiberaMemoria();
    void CriaAtributo();
    int ComparaString(char *str1, char *str2);
};
#endif /* CRIARTHREAD_H_ */

TesteQNX.cc:

#include <cstdlib>
#include <iostream>

using namespace std;

#include "CriarThread.h"

int main(int argc, char *argv[]) {
    cout << "Welcome to the Momentics IDE" << endl;
    
    CriarThread * ct;
    ct = new CriarThread;
    ct->AlocaMemoria();
    ct->CriaAtributo();
    ct->NovaThread();
    ct->AguardaFimThread();
    ct->LiberaMemoria();
    ct->FinalizaThread();
    
    return EXIT_SUCCESS;
}