C ++-Pthread，与具有无限循环的一个函数相关的多个线程

Question

I am C++ newbie and try to work with Pthread and Ncurses libraries. I am making program, which displays flying balls in the terminal screen. I created a Ball class:

In file Ball.h declaration, in Ball.c implementation. Ball.h :

class Ball {

public:
//ATTRIBUTES
    char sign;
    int x, y, direction, speed, color;
    int width, height;              //area, field size


//CONSTRUCTORS
    Ball();
    ~Ball();
    Ball(int d, int s, int yy, int xx, int c, int fH, int fW);  
    //s - start direction, v - speed, x,y- position, c-color

//GETTERS



//METHODS
    void setAreaSize(int, int);
    void moveBall(void);
};

In other file is my program which uses this class:

.../*including some libs */...

.../*declaring some attributes */...

Ball *balls;
pthread_t *threads;
int howManyBalls;
int i;              //helper for loops

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

struct timespec delay = {       //our speed or rather delay ;)
             1,
             0
    };

/* Function declarations */
void initBalls(void);
void initThreads(void);
void *threadBallFunction(void *arg);



//MAIN FUNCTION ----------------------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
    ... /*some code*/...

    initBalls();
    initThreads();

    ... /* some code */       

    return 0;
}

//FUNCTIONS IMPLEMENTATIONS ----------------------------------------------------------------------------------

/* INIT BALLS */
void initBalls(void){
    balls = new Ball[howManyBalls];     //creating our balls array with appropriate size

    int ballY, ballX, ballDirection, ballColor;

    srand(time(0));                 //resetting the random number generator

    for(i=0;i<howManyBalls;i++){
        ballY = (rand()%(frameWidth-1))-i;
        ballX = (rand()%(frameHeight-1))-i;
        ballDirection = rand()%8+1;
        ballColor = rand()%7+1;

        balls[i] = Ball(ballDirection,2,ballX,ballY,ballColor, frameHeight, frameWidth);        

    }
}

void *threadBallFunction(void *threadIndex) {
    do{
        /* WHAT HERE ?? */
    }
    while(1);
}

/* INIT THREADS */
void initThreads(void){
    threads = new pthread_t[howManyBalls];
    void *exit_status;
    int threadIdx;

    for (threadIdx = 0; threadIdx < howManyBalls; threadIdx++) {
        pthread_create(&threads[threadIdx], NULL, threadBallFunction, &threadIdx);
        pthread_join(threads[threadIdx], &exit_status);
    }
}

So, now I want that ever ball has its own thread. All threads are linked with the same function - threadBallFunction, where I will move only one ball, which ball? it will be specified by argument passed to threadBallFunction. Balls and Threads should be stored in separate arrays. Number of balls is specified by user input. Moving balls should be endless.

I dont know how to use Mutexes or Condition Variables here... looking forward for any help,

//EDIT: More precised question:

I have many threads linked to the same function with endless loop. Is it possible to use in this function Condition Variable method of synchronization threads??

//EDIT2 (Thank You Ahmed but...) Ok, it is really helpful for me. Thank you very much ;) buuuut lets say I want threads working endless and printing the "counter" value every time it is incremented, time between each incrementation or printing should be 1 sec.

For example:

counter = 0;

Thread1- IncCounterBy(2)

Thread2- IncCounterBy(5)

and my program should print:

2 (+2 after 1sec)

7 (+5 after 1sec)

9 (+2 after 1sec)

14 (+5 after 1sec)

16 (+2 after 1sec)

21 (+5 after 1sec)

... till I stop it with CTRL+C

How to manage this?

kind regards

Answer 1

Mutexes are very easy to be understood and used as well, Let's say you have a class

class A{
        static int counter;
    public:
        static void IncCounterBy(int increment){
            counter += increment;
        }
    };

Assume there is 100 threads all are accessing this function, at any time 2 threads -or more- may access the same function at the same time, each will copy the original value then increment it so if A::counter was = 3

Thread1- IncCounterBy(2)

Thread2- IncCounterBy(5)

Thread3- IncCounterBy(1)

this will end in =>> A::counter = 3;

How to use Boost::Mutex

class A{
        static int counter;
        boost::mutex Guard;
    public:
        static void IncCounterBy(int increment){
        Guard.lock();
        counter += increment;
        Guard.unlock();
        //Or you can use "boost::mutex::scoped_lock  lock(Guard);" to guard a function
    };

Answer 2

Your specific question: "Is it possible to use in this function Condition Variable method of synchronization threads"

I am still unclear as to the behavior you are really asking for so lets consider both cases:

---

Case 1: You want the threads running autonomously and each independently updating the counter on its own scheduled period:

The answer is that for this application, condition variables are not the correct method of synchronization. Condition variables are really meant for the producer consumer design pattern. In particular:

*The pthread_cond_broadcast() and pthread_cond_signal() functions shall have no effect if there are no threads currently blocked on cond. http://linux.die.net/man/3/pthread_cond_signal *

What you are asking for is autonomous processing on a shared state object (your counter). In this case Ahmed is correct in that the shared state should simply be protected by a mutex to prevent simultaneous access.

Case 2: You want each thread to do some sort of round robin processing where one thread runs, waits for 1 second and then updates the counter by its parameter amount. Then the next thread runs, wait for 1 second and updates the counter by its different parameter amount. And so on until you loop back to the first thread.

This more case matches your example counter increment flow. In this case condition variables could be used as long as the number of threads is 2 and you make sure to start them in a deterministic way. With more then 2 threads then unless they are of different priority there is no guarantee of run order. Also starting them in a loop like that does not guarantee which will be executed first.

In this case, only a single thread is working at a time while all other are waiting. This is not a good candidate for a multithreaded solution. A better patter would be a single thread and a work queue. By this I mean create a circular queue of the various increment amounts desired and let a single thread run in a loop where it waits 1 second, pull reads the next increment amount from the queue and increments the counter, increments the queue pointer, and repeats.