Linux线程同步

Linux线程同步

1.互斥量

确保同一时间只有一个线程访问数据。

pthread_mutex_t mut;
//两种初始化方法
mut = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_init(&mut, NULL);

1.初始化

int pthread_mutex_init (pthread_mutex_t *__mutex,
                              const pthread_mutexattr_t *__mutexattr);

2.销毁

 int pthread_mutex_destroy (pthread_mutex_t *__mutex)

3.加锁/解锁

extern int pthread_mutex_trylock (pthread_mutex_t *__mutex);

/* Lock a mutex.  */
extern int pthread_mutex_lock (pthread_mutex_t *__mutex);

#ifdef __USE_XOPEN2K
/* Wait until lock becomes available, or specified time passes. */
extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
                                    const struct timespec *__restrict);
#endif

/* Unlock a mutex.  */
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex);

4.按顺序输出abcd

分别定义四个锁（a锁、b锁、c锁、d锁），初始时，将四个锁全部锁住，主线程创建完子线程后，解开a锁，然后a线程输出完后解开b锁，锁住a锁，后面同理，d输出后解开a锁，锁住d锁，这样就能循环有序输出了。

#include 
#include 
#include 
#include 

#define N 4
static pthread_mutex_t muts[N];
static int flag = 1;

static int get_next(int i){
   
    if(i < N - 1)
        return i + 1;
    else
        return 0;
}

static void *pth_fun(void *arg)
{
   
    char ch = 'a';
    int i = (int)arg;
    char n = ch + i;
    while (flag)
    {
   
        pthread_mutex_lock(muts + i);
        putchar(n);
        pthread_mutex_unlock(muts + get_next(i));
    }
    pthread_exit((void *)0);
}

int main(int argc, char const *argv[])
{
   
    int err, i;
    pthread_t tids[N];
    for (i = 0; i < N; i++)
    {
   
        pthread_mutex_init(muts + i, NULL);
        pthread_mutex_lock(muts + i);
        err = pthread_create(tids + i, NULL, pth_fun, (void *)i);
        if (err)
        {
   
            fprintf(stderr, "pthread_creare() %s\n", strerror(err));
            exit(err);
        }
    }
    pthread_mutex_unlock(muts);
    sleep(3);
    flag = 0;
    for (i = 0; i < N; i++)
    {
   
        pthread_join(tids[i], NULL);
        pthread_mutex_destroy(muts + i);
    }
    return 0;
}

5.带引用计数的结构体使用

#include 
#include 
#include 
#include 

//带引用次数的结构
struct foo
{
   
    int count;
    int id;
    pthread_mutex_t mut;
};

#define N 4
static pthread_t tids[N];
static struct foo *foop;//全局指针，每个线程都能访问到

//为数据分配内存
static struct foo *foo_alloc(int id)
{
   
    struct foo *fp;
    fp = malloc(sizeof(*fp));
    if (fp == NULL)
    {
   
        perror("malloc()");
        exit(-1);
    }
    fp->count = 0;// 初始引用数为0
    fp->id = id;
    pthread_mutex_init(&fp->mut, NULL);
    return fp;
}

//每引用一次引用数+1
static void foo_hold(struct foo *fp)
{
   
    pthread_mutex_lock(&fp->mut);
    fp->count++;
    pthread_mutex_unlock(&fp->mut);
}

//释放时引用数-1
static void foo_rele(struct foo *fp)
{
   
    pthread_mutex_lock(&fp->mut);//对count操作前，加锁，防止当前线程修改时，其他线程也在修改
    if (--fp->count == 0)//引用数为0时，销毁锁，释放内存
    {
   
        printf("aaaa\n");
        pthread_mutex_unlock(&fp->mut);
        pthread_mutex_destroy(&fp->mut);
        free(fp);
        fp = NUll;
    }
    else
    {
   
        pthread_mutex_unlock(&fp->mut);
    }
}

//线程启动函数
static void *thr_fun(void *arg)
{
   
    int i = (int)arg;
    if(foop == NUll)
        pthread_exit((void *)0);
    foo_hold(foop);//引用
    printf("th%d %d,%d\n", i, foop->id, foop->count);
    sleep(2);//线程睡2秒在释放
    printf("th%d %d,%d\n", i, foop->id<