How to make a child thread waiting for the main thread

damadam Source

I've got 2 threads : one child which detects mouse events, and the other main one which execute the program.

global variable :

int g_wait = 0; 

child thread :

void *mouseEvent2(void *arg) 
{
int fd;
struct input_event ev;
const char* pFile = "/dev/input/event0";

signal(SIGINT, SAMPLE_VGS_HandleSig);
signal(SIGTERM, SAMPLE_VGS_HandleSig);

fd = open(pFile, O_RDONLY);
if (fd == -1) {
    printf("ERROR Opening %s\n", pFile);
    return NULL;
}

while(scroll != -1) {
    read(fd, &ev, sizeof(ev));

    [... Some code with if statement ... ]
    if(...) //left mouse button
        g_wait = !g_wait;

    [need waiting so the thread won't use at 100% a core]
}
close(fd);
(void) arg;
pthread_exit(NULL);
}

Main thread :

int main() {
[... some code and initilisation here ...]
if(pthread_create(&scrollThread, NULL, mouseEvent2, NULL))
    goto _FAILURE_;
do {
    [...]
    while(g_wait);
}
[... some deinit ...]
_FAILURE_ :
pthread_join(scrollThread, NULL);
[... some other deinit ...]
return 0;
}

My problem is : when my main is waiting, my child thread is using at 100% 1 core processor, so which function can I use to pause the child thread with the main one?

I already consult How to make main thread wait for all child threads finish? but it didn't help me totally.

cmultithreading

Answers

answered 1 week ago kerrytazi #1

So, if you want to pause main thread until child thread signals about it ends, you can use mutexes to lock main thread:

#include "stdio.h"
#include "pthread.h"

/* I work on windows now, so i need windows sleep function to test example */
/* platform independed sleep function */
#ifdef _WIN32
# include "windows.h"
# define platform_sleep(ms) Sleep(ms)
#else
# include "unistd.h"
# define platform_sleep(s) sleep(s / 1000)
#endif


pthread_mutex_t mtx;


void *
child_func(void *arg)
{
    /* simulate some hard work */
    platform_sleep(3000); /* 3 secs */

    /* after this "hard work" we allow main thread to continue */
    pthread_mutex_unlock(&mtx);
}



int
main()
{
    pthread_mutex_init(&mtx, NULL);
    pthread_mutex_lock(&mtx);

    pthread_t child;
    pthread_create(&child, NULL, child_func, NULL);

    /* mutex is already locked by main thread, so it waits */
    /* until child thread unlock it */
    pthread_mutex_lock(&mtx);
    pthread_mutex_destroy(&mtx);

    /* do work after child ends */
}

comments powered by Disqus