基于原子操作的无睡眠锁实现

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

typedef struct
{
	volatile unsigned long count;
} atomic_t;

void atomic_inc(unsigned long *ptr)
{
    __asm__("incl %0;\n"
        : "+m"(*ptr));
}
static inline int atomic_xchg(atomic_t* v, int i)
{
	int ret;
	asm volatile(
		"xchgl %0, %1"
		:"=r"(ret)
		:"m"(v->count),"0"(i)
	);

	return ret;
}

void mutex_lock(atomic_t* v)
{
	while (1 == atomic_xchg(v, 1)) {
		sched_yield(); //获取锁失败后，放弃CPU
	}
}

static atomic_t atomic;
unsigned long counter = 0;
void mutex_unlock(atomic_t* v)
{
	v->count = 0;
}

void *read_msg_server(void *p)
{
	while(1)
	{
		mutex_lock(&atomic);
		atomic_inc(&counter);
		printf("%s line %d. counter %ld.\n", __func__, __LINE__, counter);
		mutex_unlock(&atomic);
	}
	return NULL;
}

void *write_msg_server(void *p)
{
	while(1)
	{
		mutex_lock(&atomic);
		atomic_inc(&counter);
		printf("%s line %d. counter %ld.\n", __func__, __LINE__, counter);
		mutex_unlock(&atomic);
	}
	return NULL;
}

void *final_msg_server(void *p)
{
	while(1)
	{
		mutex_lock(&atomic);
		atomic_inc(&counter);
		printf("%s line %d. counter %ld.\n", __func__, __LINE__, counter);
		mutex_unlock(&atomic);
	}
	return NULL;
}

int main(void)
{
	atomic.count = 0;
    pthread_t pthread1;
    pthread_t pthread2;
    pthread_t pthread3;
    
 
    int err = pthread_create(&pthread1, NULL, read_msg_server, NULL);
    if(err != 0)
    {
        perror("create pthread failure.");
        return -1;
    }
 
    err = pthread_create(&pthread2, NULL, write_msg_server, NULL);
    if(err != 0)
    {
        perror("create pthread failure.");
        return -1;
    }
 
    err = pthread_create(&pthread2, NULL, final_msg_server, NULL);
    if(err != 0)
    {
        perror("create pthread failure.");
        return -1;
    }
 
    pthread_join(pthread2, NULL);
    pthread_join(pthread1, NULL);
    pthread_join(pthread3, NULL);
 
    return 0;
}

结束