Home/ Questions/Q 7027439
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-28T00:14:49+00:00

Here is the thing: there is a float array float bucket[5] and 2 threads,

  • 0

Here is the thing: there is a float array float bucket[5] and 2 threads, say thread1 and thread2.

Thread1 is in charge of tanking up the bucket, assigning each element in bucket a random number. When the bucket is tanked up, thread2 will access bucket and read its elements.

Here is how I do the job:

float bucket[5];
pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
pthread_t thread1, thread2;

void* thread_1_proc(void*);  //thread1's startup routine, tank up the bucket 
void* thread_2_proc(void*);  //thread2's startup routine, read the bucket 

int main()
{
    pthread_create(&thread1, NULL, thread_1_proc, NULL);
    pthread_create(&thread2, NULL, thread_2_proc, NULL);
    pthread_join(thread1);
    pthread_join(thread2);
}

Below is my implementation for thread_x_proc:

void* thread_1_proc(void*)
{
    while(1) { //make it work forever
        pthread_mutex_lock(&mu);  //lock the mutex, right?

        cout << "tanking\n";
        for(int i=0; i<5; i++)
            bucket[i] = rand();  //actually, rand() returns int, doesn't matter

        pthread_mutex_unlock(&mu); //bucket tanked, unlock the mutex, right?

        //sleep(1); /* this line is commented */
    }
}

void* thread_2_proc(void*)
{
    while(1) { 
        pthread_mutex_lock(&mu);

        cout << "reading\n";
        for(int i=0; i<5; i++)
            cout << bucket[i] << " ";  //read each element in the bucket

        pthread_mutex_unlock(&mu); //reading done, unlock the mutex, right?

        //sleep(1); /* this line is commented */
    }
}

Question

Is my implementation right? Cuz the output is not as what I expected.

...
reading
5.09434e+08 6.58441e+08 1.2288e+08 8.16198e+07 4.66482e+07 7.08736e+08 1.33455e+09 
reading
5.09434e+08 6.58441e+08 1.2288e+08 8.16198e+07 4.66482e+07 7.08736e+08 1.33455e+09 
reading
5.09434e+08 6.58441e+08 1.2288e+08 8.16198e+07 4.66482e+07 7.08736e+08 1.33455e+09 
reading
tanking
tanking
tanking
tanking
...

But if I uncomment the sleep(1); in each thread_x_proc function, the output is right, tanking and reading follow each other, like this:

...
tanking
reading
1.80429e+09 8.46931e+08 1.68169e+09 1.71464e+09 1.95775e+09 4.24238e+08 7.19885e+08 
tanking
reading
1.64976e+09 5.96517e+08 1.18964e+09 1.0252e+09 1.35049e+09 7.83369e+08 1.10252e+09 
tanking
reading
2.0449e+09 1.96751e+09 1.36518e+09 1.54038e+09 3.04089e+08 1.30346e+09 3.50052e+07
...

Why? Should I use sleep() when using mutex?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Your code is technically correct, but it does not make a lot of sense, and it does not do what you assume.

    What your code does is, it updates a section of data atomically, and reads from that section, atomically. However, you don’t know in which order this happens, nor how often the data is written to before being read (or if at all!).

    What you probably wanted is generate exactly one sequence of numbers in one thread every time and read exactly one new sequence each time in the other thread. For this, you would use either have to use an additional semaphore or better a single-producer-single-consumer queue.

    In general the answer to “when should I use a mutex” is “never, if you can help it”. Threads should send messages, not share state. This makes a mutex most of the time unnecessary, and offers parallelism (which is the main incentive for using threads in the first place).

    The mutex makes your threads run lockstep, so you could as well just run in a single thread.

    • 0