如何在本地使用互斥变量锁定线程？

Question

When i programming mutex in pthread i used to make mutex lock variable ( pthread_mutex_t mutex ) globally. When i see many example program most of the cases mutex variable placed globally.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *add1_fun(void* arg);
void *add2_fun(void* arg);
pthread_mutex_t mutex;

void *add1_fun(void* arg) 
{
    int t_num = (int)arg;
    int i = 0;

    pthread_mutex_lock(&mutex);

    printf("Thread %d created and running \n", t_num); /*critical section start*/
    sleep(3);
    printf("Thread %d finishes the work\n", t_num); /*critical section end*/
    pthread_mutex_unlock (&mutex);

    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    pthread_t mythread1;
    pthread_t mythread2;
    pthread_attr_t myattr;
    void *joinResult;
    int x = 0;
    int t_arg = 1;
    pthread_mutex_init(&mutex, NULL);
    pthread_attr_init(&myattr);
    pthread_attr_setdetachstate(&myattr, PTHREAD_CREATE_JOINABLE);                 

    if((pthread_create(&mythread1, &myattr, add1_fun,  (void*)t_arg) != 0)){
        printf("Error, thread not created properly\n");
        return 1;
    }
    t_arg = 2;
    if((pthread_create(&mythread2, &myattr, add1_fun,  (void*)t_arg) != 0)){
        printf("Error, thread not created properly\n");
        return 1;
    }
    pthread_attr_destroy(&myattr);
    if(pthread_join(mythread1, &joinResult) != 0 ){
        printf("Error pthread join \n");
        return 1;
    }
    printf("Main : Thread1 joined with result of %d\n", (int)joinResult);
    if(pthread_join(mythread2, &joinResult) != 0 ){
        printf("Error pthread join \n");
        return 1;
    }
    printf("Main : Thread2 joined with result of %d\n", (int)joinResult);
    printf("main finishes the work\n");

    pthread_exit(NULL);
}

What is my doubt is, In this situation everywhere in the program can take mutex variable and do lock and unlock the mutex. This will reduce security.

Is it possible to make lock in the thread by making mutex variable locally in thread handler. like below program structure

void *add1_fun(void* arg)
{
    pthread_mutex_t mutex;
    pthread_mutex_lock(&mutex);

/* critical section */

    pthread_mutex_unlock (&mutex);
}
int main()
{
   /* code */
}

I think this question may take no sense, please help me out, I am not good at multi threading.

I am using gcc under linux.

Thanks.

Answer 1

A local variable is local to just the specific function invocation. If you want a "local" variable to be static between function invocations then you have to make the variable static .

Answer 2

The idea of mutex, is that everyone can try to lock it, but, at any time only one will succeed.

If you use local mutex, you can lock it. but other threads, will create their own local mutex, and will also succeed to lock it. not really the point, is it...

If you dont want to use the mutex globaly, you can declare it as atatic, and then, everyone will use the same mutex.

Answer 3

What is a mutex ?

It is an object used for accesing programs resources by more than one threads, but only one thread at any time has access to the resource. I don't think that you have to think for security issuses from the mutex perspective, because once locked, only the thread that locked it can unlock it.

So you either make the mutex global, or static, but never local.

Answer 4

The problem is that if you declared a mutex as a local variable to a function, such as:

void foo() {
    pthread_mutex_t mutex;
    /* ... */
}

It wouldn't work because every time someone calls foo(), it "creates" a brand new mutex and it can't be used to synchronise to invocation to foo() because the two caller will not lock the same mutex.

The only solution, if you don't want to place the "mutex" variable in some global file or similar, is to declared is as static

void foo() {
    static pthread_mutex_t mutex;
    /* ... */
}

However, please bear in mind that this is anyway a global mutex! This means that you can anyway pass the &mutex to some other function like:

void corrupt_it(pthread_mutex_t *p_mutex);
void foo() {
    static pthread_mutex_t mutex;
    corrupt_it(&mutex);
}

Answer 5

A local mutex locks the section of code in one thread. The other thread also will lock it. And the next one too. But none of them knows about the other locks. So You will achieve mostly no thread-safety if you use the local approach.

Answer 6

If you put it locally its scope will be local. Every instance of the function will have its own little local mutex that has no connection to the others.

Answer 7

You can keep each thread's worker function argument independent, and with a pointer pointing to the same "manager" variable, which hold the mutex .

As a reference code example, using 4 threads to save money to a same bank account, I create two structs thread_manager_t and thread_data_t , thus there is no global variables.

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

// all thread's thread_data_t variable will pointing to the same thread_manager_t variable
struct thread_manager_t
{
    int total_money;
    pthread_mutex_t mutex;
};

// each thread will have an independent thread_data_t variable
struct thread_data_t
{
    thread_manager_t* manager;
};

void* save_money_to_bank(void* param)
{
    thread_data_t* thread_data = (thread_data_t*)param;
    for (int i = 0; i < 10000; i++)
    {
        pthread_mutex_lock(&thread_data->manager->mutex);
        thread_data->manager->total_money++;
        pthread_mutex_unlock(&thread_data->manager->mutex);
    }
    return NULL;
}

int main()
{
    const int thread_num = 4;
    pthread_t t[thread_num];

    thread_data_t* thread_data = (thread_data_t*)malloc(sizeof(thread_data_t) * thread_num);
    thread_manager_t thread_manager;
    pthread_mutex_init(&thread_manager.mutex, NULL);
    for (int i = 0; i < thread_num; i++)
    {
        thread_data[i].manager = &thread_manager;
        pthread_create(&t[i], NULL, save_money_to_bank, &thread_data[i]);
    }

    for (int i = 0; i < thread_num; i++)
    {
        pthread_join(t[i], NULL);
    }

    printf("finally, total_money = %d\n", thread_manager.total_money);

    free(thread_data);
    pthread_mutex_destroy(&thread_manager.mutex);

    return 0;
}