C 语言的 互斥锁、自旋锁、原子操作

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

#define PTHREAD_NUM 10
#define INFO printf


pthread_mutex_t mutex;
pthread_spinlock_t spin;


int inc(int *v,int add)
{
 int old;
    //汇编，做一个原子操作
 __asm__ volatile(
  "lock;xaddl %2, %1;"
  :"=a" (old)
  :"m"(*v),"a"(add)
  :"cc","memory"
 );
 
 return old;
}

void * thread_callback(void *arg)
{
 int *count = (int *)arg;

 int i = 100000;
 
while(i--)
 {
 #if 0
//互斥锁
  pthread_mutex_lock(&mutex);
  (*count)++;
  pthread_mutex_unlock(&mutex);
 #elif 0
//自旋锁
  pthread_spin_lock(&spin);
  (*count)++;
  pthread_spin_unlock(&spin);
 #else
//原子操作
  inc(count,1);
 
 #endif
  usleep(1);
 }

}

int main()
{
 pthread_t thread[PTHREAD_NUM] = {0};
 pthread_mutex_init(&mutex,NULL);
 pthread_spin_init(&spin,0);
 
 int count  = 0;

 for(int i = 0;i<PTHREAD_NUM;i++){
  pthread_create(&thread[i],NULL,thread_callback,&count);
 }

 for(int i = 0;i<100;i++)
 {
  INFO("count == %d\n",count);
  sleep(1);
 }
  
 
 return 0;
}

//并发
//互斥锁mutex
// 如果获取不到资源会让出cpu
// 使用场景
//  共享区域执行的内容较多的情况
//自旋锁spinlock
// 如果获取不到资源，会原地自旋，忙等
// 使用场景
//  共享区域执行的内容较少的情况
//原子操作
// 不可分割
// 使用场景
//  做简单++、--操作
//


#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

#define MAX_PTHREAD 2
#define LOOP_LEN    1000000000
#define LOOP_ADD    10000

int count = 0;

pthread_mutex_t mutex;
pthread_spinlock_t spin;

typedef void *(*functhread)(void *arg);

void do_add(int num)
{
 int sum = 0;
 for(int i = 0;i<num;i++)
 {
  sum +=i;
 }
}

int atomic_add(int *v,int add)
{
 int old;

 __asm__ volatile(
  "lock;xaddl %2, %1;"
  :"=a" (old)
  :"m"(*v),"a"(add)
  :"cc","memory"
 );
 
 return old;
}

void * atomicthread(void *arg)
{

 for(int i  = 0;i<LOOP_LEN;i++){
  atomic_add(&count,1);
 }
}


void * spinthread(void *arg)
{
 for(int i  = 0;i<LOOP_LEN;i++){

  pthread_spin_lock(&spin);
  count++;
  //do_add(LOOP_ADD);
  pthread_spin_unlock(&spin);

 }
}

void * mutexthread(void *arg)
{
 for(int i  = 0;i<LOOP_LEN;i++){

  pthread_mutex_lock(&mutex);
  count++;

  //do_add(LOOP_ADD);
  pthread_mutex_unlock(&mutex);

 }
}

int test_lock(functhread thre,void * arg)
{

 clock_t start = clock();
 pthread_t tid[MAX_PTHREAD] = {0};

 for(int i = 0;i<MAX_PTHREAD;i++)
 {
 //创建线程
  int ret = pthread_create(&tid[i],NULL,thre,NULL);
  if(0 != ret)
  {
   printf("pthread create rror\n");
   return -1;
  }
 }

 for(int i = 0;i<MAX_PTHREAD;i++){
//回收线程
  pthread_join(tid[i],NULL);
 }

 clock_t end = clock();

 //printf("start  -- %ld\n",start);
 //printf("end  -- %ld\n",end);
 //printf("CLOCKS_PER_SEC  -- %ld\n",CLOCKS_PER_SEC);
 printf("spec lock is  -- %ld\n",(end - start)/CLOCKS_PER_SEC);

}


int main()
{
 pthread_mutex_init(&mutex,NULL);
 pthread_spin_init(&spin,0);
//测试spin
 count = 0;
 printf("use spin ------ \n");
 test_lock(spinthread,NULL);
 printf("count == %d\n",count);


//测试mutex
 count = 0;
 printf("use mutex ------ \n");
 test_lock(mutexthread,NULL);
 printf("count == %d\n",count);

//测试atomic
 count = 0;
 printf("use automic ------ \n");
 test_lock(atomicthread,NULL);
 printf("count == %d\n",count);

 return 0;
}