C语言线程间共享指针

C语言的线程间共享指针是指在多个线程中使用同一个指针指向的内存空间，使得不同的线程可以同时修改同一个变量或者结构体。在使用之前需要注意以下几点：

1. 线程安全：由于多个线程可能同时访问同一块内存空间，因此需要保证线程安全，防止竞争条件导致的错误发生。

2. 同步机制：为了保证线程间的协调，需要使用一些同步机制，如互斥锁、条件变量等。

下面给出线程间共享指针的使用攻略：

1. 定义共享指针：首先需要定义一个指针，该指针指向需要共享的变量或结构体。

int *p_share;

1. 初始化共享指针：初始化共享指针的值，使其指向一个已分配的内存空间。

p_share = (int*)malloc(sizeof(int));
*p_share = 0;

1. 创建线程：创建多个线程，使它们共享同一个指针。

pthread_t thread1, thread2;
pthread_create(&thread1, NULL, thread_func1, NULL);
pthread_create(&thread2, NULL, thread_func2, NULL);

1. 定义线程函数：定义线程函数，通过参数传递共享指针。

void *thread_func1(void *arg)
{
    int *p_share = (int*)arg;
    // do something
}

void *thread_func2(void *arg)
{
    int *p_share = (int*)arg;
    // do something
}

1. 线程之间共享指针：多个线程之间共享同一个指针。

pthread_join(thread1, NULL);
pthread_join(thread2, NULL);

1. 完成共享操作：每个线程完成共享操作之后，需要释放共享指针所指向的内存空间。

free(p_share);

下面给出两个示例说明共享指针的使用方法：

示例1：

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

void *thread_func1(void *arg)
{
    int *p_share = (int*)arg;
    for (int i = 0; i < 10; i++)
    {
        (*p_share)++;
    }
    pthread_exit(NULL);
}

void *thread_func2(void *arg)
{
    int *p_share = (int*)arg;
    for (int i = 0; i < 10; i++)
    {
        (*p_share)--;
    }
    pthread_exit(NULL);
}

int main()
{
    int *p_share;
    p_share = (int*)malloc(sizeof(int));
    *p_share = 0;

    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, thread_func1, (void*)p_share);
    pthread_create(&thread2, NULL, thread_func2, (void*)p_share);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("共享指针的值为：%d\n", *p_share);

    free(p_share);
    return 0;
}

示例2：

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

pthread_mutex_t mutex;
void *thread_func1(void *arg)
{
    int *p_share = (int*)arg;
    for (int i = 0; i < 10; i++)
    {
        pthread_mutex_lock(&mutex);
        (*p_share)++;
        printf("线程1修改共享指针的值：%d\n", *p_share);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

void *thread_func2(void *arg)
{
    int *p_share = (int*)arg;
    for (int i = 0; i < 10; i++)
    {
        pthread_mutex_lock(&mutex);
        (*p_share)--;
        printf("线程2修改共享指针的值：%d\n", *p_share);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

int main()
{
    int *p_share;
    p_share = (int*)malloc(sizeof(int));
    *p_share = 0;

    pthread_mutex_init(&mutex, NULL);

    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, thread_func1, (void*)p_share);
    pthread_create(&thread2, NULL, thread_func2, (void*)p_share);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("共享指针的值为：%d\n", *p_share);

    pthread_mutex_destroy(&mutex);
    free(p_share);
    return 0;
}

以上两个示例分别实现了两个线程修改同一个共享指针的值，并通过互斥锁和printf语句保证线程安全和输出顺序的一致性。