Work with threads

If we assume that one of the threads calculates the movement of the machines, and takes over the rendering, and the second, accepts user commands, then you should take into account several important things:

1. For both your streams, there is a common dataset - say, an array with the current position of the cars and the “pedestrian” on the map, if a separate stream is involved in drawing. In the example you cited, where the calculation of the movement of cars and the display fit in one stream, the position of the pedestrian will be this general data. This data must be global. At each time, these data should be consistently displayed on the screen.
2. Since these are shared data, calls to them in both threads must be synchronized using a mutex. You cannot change the position of a pedestrian in one of the flows without resorting to capturing a mutex, since the second flow at this time can (or even should!) Use the position of the pedestrian to be displayed on the screen.

Therefore we come to this option:

1. In the stream function that accepts user commands, after entering the stroke, the position of the pedestrian changes under the mutex

    while((buf=getchar())!='q') { pthread_mutex_lock(my_mutex); if((buf == 'a') && (froggy.x > OUTER_BORDER)) froggy.x--; if((froggy.x < (SCREEN_WIDTH - OUTER_BORDER))) froggy.x++; ... pthread_mutex_unlock(my_mutex); } 

2. Either capture the same mutex at the time of display, or before displaying the picture on the screen, under the mutex, copy the position of the pedestrian to display correctly:

    ... moveCarsOnMotorway(); startCar((SCREEN_WIDTH - OUTER_BORDER)); pthread_mutex_lock(my_mutex); temp_froggy = froggy; pthread_mutex_unlock(my_mutex); drawScreen(); ... 

3. When displayed, draw the saved pedestrian coordinates.

4. It is absolutely wrong to try to display something from both streams on the screen (all output from the stream reading user commands must be removed), nothing good will come of it. It is better when adding a picture to add to the beginning a static label with a hint of keys for moves.

UPDATE

1. In connection with this question, should they be exclusively in the stream and cannot be called from main () *?

   When you call main (), it is already 1 thread. When you create another pthread_create () function inside, there are already two of them, that's why I described two. Accordingly, the drawing functions can also be called from main (), the main thing is that these functions draw the data already agreed with the second flow (the position of the pedestrian must be copied under the mutex and passed to the drawing function, or the entire drawing function that uses the global variable with the position of the pedestrian, should be called under the mutex).

2. is it enough to write one mutex, and it will act on all variables declared globally?

   A mutex is protected by a common resource; it can be at least a variable, at least ten variables, arrays or structures, if they are logically connected. It is important that if the mutex is properly used, while it is captured by one thread, other threads cannot capture it, and will hang waiting for the mutex to be released. At this time, the thread that captures the mutex must work alone with the protected data. That is, if there is any data common to the streams, they cannot be read or modified at all without first capturing the mutex.

In this example, I do not describe a workable program, but I show the logic of my implementation, in a simplified form, the interaction of threads using the ncurses library

In the main thread, the main() function works with the ncurses library to draw and handle keystrokes. In the second thread, the calculate() function takes place all the calculations.

To work with threads, we create three blocks of variables (mixing along the X axis and mixing along the Y axis)

 int x_1; /*переменые первого потока*/ int y_1; int x_2; /*переменые второго потока*/ int y_2; int x_t; /*переменые проброса*/ int y_t; 

At the beginning, we initialize the ncurses library and configure the main program variables.

 initscr(); cbreak(); /*убрать режим буфферизации*/ noecho(); /*не выводить набираемые символы */ nodelay(stdsrc,TRUE); /*сделать не блокирующий режим*/ keypad(stdsrc,TRUE); /*не обрабатывать служебные клавиши*/ 

we initialize a mutex for working with threads

 pthread_mutex_t mutex; pthread_mutex_init(&mutex,NULL); 

start the function of the second thread

  pthread_t thread; pthread_create(&thread, NULL,calculate, NULL); 

in the main() function go to the main loop

 for(;;){ buf = getchar(); if(buf != ERR){ /*нажата клавиша*/ switch(buff){ ..... case 'w': y_1++; break; ..... } } /*захватываем мьютекс */ pthread_mutex_lock(&mutex); /*записываем переменые */ y_t = y_1; x_1 = x_t; /*освобождаем мьютекс*/ pthread_mutex_unlock(&mutex); /*прорисовываем элементы на экране */ draw_screen(y_1,x_1); /*если прорисовка 25 кадров в секунду засыпаем на 40 микросекунд*/ usleep(40); } 

displacement calculation function

 calculate() { for(;;){ pthread_mutex_lock(&mutex); /*записываем переменые */ y_2 = y_t; pthread_mutex_unlock(&mutex); /*проводим рассчет перемешения*/ x_2 = calculate(y_2); pthread_mutex_lock(&mutex); /*записываем переменые */ x_t = x_2; pthread_mutex_unlock(&mutex); } usleep(10); }