Linux系统编程 线程同步

最新推荐文章于 2024-09-13 16:17:52 发布
最新推荐文章于 2024-09-13 16:17:52 发布
阅读量199 收藏
点赞数
分类专栏： Linux系统学习 文章标签： 开发语言 服务器 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryiju5yujty/article/details/127947657
版权

学习目标：

  • 熟练掌握互斥量的使用
  • 说出什么叫死锁以及解决方案
  • 熟练掌握读写锁的使用
  • 熟练掌握条件变量的使用
  • 理解条件变量实现的生产消费者模型
  • 理解信号量实现的生产消费者模型

1 互斥锁

1.1互斥锁的使用步骤

  • 第1步：创建一把互斥锁
pthread_mutex_t mutex;
  • 初始化互斥锁
pthread_mutex_init(&mutex);---相当于mutex=1
  • 在代码中寻找共享资源（也称为临界区）
pthread_mutex_lock(&mutex);  -- mutex = 0

[临界区代码]

pthread_mutex_unlock(&mutex); -- mutex = 1
  • 释放互斥锁资源
pthread_mutex_destroy(&mutex);

注意：必须在所有操作共享资源的线程上都加上锁否则不能起到同步的效果。

1.2 练习

编写思路：

1 定义一把互斥锁，应该为一全局变量

pthread_mutex_t mutex;

2 在main函数中对mutex进行初始化

pthread_mutex_init(&mutex, NULL);

3 创建两个线程，在两个线程中加锁和解锁

4 主线程释放互斥锁资源

pthread_mutex_destroy(&mutex);

 

 1.3 死锁

死锁并不是linux提供给用户的一种使用方法，而是由于用户使用互斥锁不当引起的一种现象。

  • 常见的死锁有两种：
  • 第一种：自己锁自己，如下图代码片段

  • 第二种 线程A拥有A锁，请求获得B锁；线程B拥有B锁，请求获得A锁，这样造成线程A和线程B都不释放自己的锁，而且还想得到对方的锁，从而产生死锁，如下图所示：

 

  • 保证加锁的时候不嵌套或者不让两个线程同时拥有两把锁就不会产生死锁。
  • 如何解决死锁：
  • 让线程按照一定的顺序去访问共享资源
  • 在访问其他锁的时候，需要先将自己的锁解开
  • 调用pthread_mutex_trylock，如果加锁不成功会立刻返回
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//创建互斥量
 pthread_mutex_t mutex;

//使用互斥量的步骤
//1 创建全局互斥量  需要在创建线程前 创建pthread_mutex_t mutex
//2 初始化互斥量 pthread_mutex_init(&mutex) 函数 函数描述：初始化一个互斥锁(互斥量) ---> 初值可看作1
//3 加锁 pthread_mutex_lock函数 	对互斥所加锁，可理解为将mutex--
//4 解锁 pthread_mutex_unlock函数 对互斥所解锁，可理解为将mutex ++
//5 尝试加锁 pthread_mutex_trylock函数

#define NUM 5000
int num = 0;

void * mythread(void *arg)
{
    int cur;
    for (int  i = 0; i < NUM; i++)
    {
      //加锁
      pthread_mutex_lock(&mutex);

      //这里写让CPU轮转时间片出现概率增加
       cur = num;
       cur++;

       //如果CPU执行到这里切换了时间片 那么会另外一个子线程得到的num为之前的值 没有进行++操作 会导致两次只增加了一次
       //从而导致最后的结果变少
       num = cur;

      //解锁
      pthread_mutex_unlock(&mutex);
    }
}

void * mythread2(void *arg)
{
    int cur;
    for (int  i = 0; i < NUM; i++)
    {
       //加锁
      pthread_mutex_lock(&mutex);

       cur = num;
       cur++;
       num = cur;

      //解锁
      pthread_mutex_unlock(&mutex);
    }
}

int main()
{
    //初始化互斥量 
    pthread_mutex_init(&mutex, NULL);

    pthread_t thread;
    int ret = pthread_create(&thread, NULL, mythread, NULL);
    if (ret != 0 )
    {
       printf("thread creat error : [%s]", strerror(ret));
       return -1;
    }

    pthread_t thread2;
    ret = pthread_create(&thread2, NULL, mythread2, NULL);
    if (ret != 0 )
    {
       printf("thread creat error : [%s]", strerror(ret));
       return -1;
    }

    //回收子线程
    pthread_join(thread, NULL);
    pthread_join(thread2, NULL);

    //输出最后的数字
    printf("NUM = [%d]\n", num);

   //释放互斥量
   pthread_mutex_destroy(&mutex);

   return 0;
}

2 读写锁

  • 什么是读写锁
  • 读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。
  • 读写锁使用场合
  • 读写锁非常适合于对数据结构读的次数远大于写的情况。
  • 读写锁特性  
  • 读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞。
  • 读写锁是“读模式加锁”时，如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
  • 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高
  • 读写锁场景练习:
  • 线程A加写锁成功, 线程B请求读锁
  • 线程B阻塞
  • 线程A持有读锁, 线程B请求写锁
  • 线程B阻塞
  1. 线程A拥有读锁, 线程B请求读锁
  • 线程B加锁成功
  1. 线程A持有读锁, 然后线程B请求写锁, 然后线程C请求读锁
  • B阻塞，c阻塞 -        写的优先级高
  • A解锁，B线程加写锁成功，C继续阻塞
  • B解锁，C加读锁成功
  1. 线程A持有写锁, 然后线程B请求读锁, 然后线程C请求写锁
  • BC阻塞
  • A解锁，C加写锁成功，B继续阻塞
  • C解锁，B加读锁成功
  • 读写锁总结

读并行，写独占，当读写同时等待锁的时候写的优先级高

  • 读写锁主要操作函数
  1. 定义一把读写锁
pthread_rwlock_t rwlock;
  1. 初始化读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
  • 函数参数
  1. rwlock-读写锁
  2. attr-读写锁属性，传NULL为默认属性
  • 销毁读写锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); 

   加读锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);      

        尝试加读锁

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
  • 加写锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
  • 尝试加写锁
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
  • 解锁
int pthread_rwlock_unlock(&pthread_rwlock_t *rwlock);

练习：3个线程不定时写同一全局资源，5个线程不定时读同一全局资源

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

//测试读写锁 读写锁步骤和互斥锁类似 当读的操作远大于写的操作时 读写锁的效率高
//读写锁是一把锁
//使用读写锁的步骤
//1 创建全局读写锁  需要在创建线程前 创建pthread_rwlock_t  rwlock;
//2 初始化读写锁 pthread_rwlock_init(&rwlock) 函数 
//3 加锁 pthread_rwlock_rdlock(&rwlock)函数 	------->加读锁
//       pthread_rwlock_wrlock(&rwlock)函数 ------->加写锁
//4 解锁 pthread_rwlock_unlock(&rwlock)函数 
//5 销毁锁 pthread_rwlock_destroy(&rwlock)

int num = 0;

//初始化读写锁
pthread_rwlock_t rwlock;

//写函数
void * thread_write(void * arg)
{
   int i = *(int *) arg;
   int cur;

   //写值
   while (1)
   {
      //加读锁
      pthread_rwlock_wrlock(&rwlock);

      cur = num;
      cur++;
      num = cur;
      printf("[%d]--W:[%d]\n", i, cur);

      //解锁
      pthread_rwlock_unlock(&rwlock);

      usleep(500);
   }
}

//读函数
void * thread_read(void * arg)
{
   int i = *(int *) arg;

   int cur;

   //读值
   while (1)
   {
      //加写锁
      pthread_rwlock_rdlock(&rwlock);

      cur = num;
      printf("[%d]--R:[%d]\n", i, cur);

      //解锁
      pthread_rwlock_unlock(&rwlock);

      usleep(400);
   }
}

int main()
{
   int i = 8;
   int arr[8];
   pthread_t thread[8];

   //初始化锁
   pthread_rwlock_init(&rwlock, NULL);

   //创建三个写线程
   for (int i = 0; i < 3; i++)
   {
      arr[i] = i;
      pthread_create(&thread[i], NULL, thread_write, &arr[i]);
   }
   
   //创建5个写线程
   for (i = 3; i < 8; i++)
   {
      arr[i] = i;
      pthread_create(&thread[i], NULL, thread_read, &arr[i]);
   }
   
   //回收线程
   for (int j = 0; j < 8; j++)
   {
      pthread_join(thread[j], NULL);
   }
   
   //销毁锁 
   pthread_rwlock_destroy(&rwlock);

   return 0;
}

 3 条件变量

  • 条件本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。
  1. 使用互斥量保护共享数据;
  2. 使用条件变量可以使线程阻塞, 等待某个条件的发生, 当条件满足的时候解除阻塞.
  • 条件变量的两个动作:
  1. 条件不满足, 阻塞线程
  2. 条件满足, 通知阻塞的线程解除阻塞, 开始工作.
  • 条件变量相关函数
pthread_cond_t  cond;
  • 定义一个条件变量
int pthread_cond_init(pthread_cond_t *restrict cond,
                   const pthread_condattr_t *restrict attr);
  • 函数描述:初始化条件变量
  • 函数参数:

                  cond: 条件变量

                  attr: 条件变量属性, 通常传NULL

  • 函数返回值:成功返回0, 失败返回错误号
int pthread_cond_destroy(pthread_cond_t *cond);
  • 函数描述: 销毁条件变量
  • 函数参数: 条件变量
  • 返回值: 成功返回0, 失败返回错误号
int pthread_cond_wait(pthread_cond_t *restrict cond,
                   pthread_mutex_t *restrict mutex);
  • 函数描述: 条件不满足, 引起线程阻塞并解锁;

          条件满足, 解除线程阻塞, 并加锁

  • 函数参数:

cond: 条件变量

mutex: 互斥锁变量

  • 函数返回值: 成功返回0, 失败返回错误
 int pthread_cond_signal(pthread_cond_t *cond);
  • 函数描述: 唤醒至少一个阻塞在该条件变量上的线程
  • 函数参数: 条件变量
  • 函数返回值: 成功返回0, 失败返回错误号

使用条件变量的代码片段

上述代码中，生产者线程调用pthread_cond_signal函数会使消费者线程在pthread_cond_wait处解除阻塞 

//使用条件变量实现生产者和消费者模型
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
typedef struct node
{
	int data;
	struct node *next;
}NODE;

NODE *head = NULL;

//定义一把锁
pthread_mutex_t mutex;

//定义条件变量
pthread_cond_t cond;

//生产者线程
void *producer(void *arg)
{
	NODE *pNode = NULL;
	while(1)
	{
		//生产一个节点
		pNode = (NODE *)malloc(sizeof(NODE));
		if(pNode==NULL)
		{
			perror("malloc error");
			exit(-1);
		}
		pNode->data = rand()%1000;
		printf("P:[%d]\n", pNode->data);

		//加锁
		pthread_mutex_lock(&mutex);

		pNode->next = head;
		head = pNode;

		//解锁
		pthread_mutex_unlock(&mutex);

		//通知消费者线程解除阻塞
		pthread_cond_signal(&cond);
		
		sleep(rand()%3);
	}
}


//消费者线程
void *consumer(void *arg)
{
	NODE *pNode = NULL;
	while(1)
	{
		//加锁
        pthread_mutex_lock(&mutex);
		
		if(head==NULL)
		{
			//若条件不满足,需要阻塞等待
			//若条件不满足,则阻塞等待并解锁;
			//若条件满足(被生成者线程调用pthread_cond_signal函数通知),解除阻塞并加锁 
			pthread_cond_wait(&cond, &mutex);
		}

		printf("C:[%d]\n", head->data);	
		pNode = head;
		head = head->next;

		//解锁
		pthread_mutex_unlock(&mutex);

		free(pNode);
		pNode = NULL;

		sleep(rand()%3);
	}
}

int main()
{
	int ret;
	pthread_t thread1;
	pthread_t thread2;

	//初始化互斥锁
	pthread_mutex_init(&mutex, NULL);

	//条件变量初始化
	pthread_cond_init(&cond, NULL);

	//创建生产者线程
	ret = pthread_create(&thread1, NULL, producer, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}

	//创建消费者线程
	ret = pthread_create(&thread2, NULL, consumer, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}

	//等待线程结束
	pthread_join(thread1, NULL);
	pthread_join(thread2, NULL);

	//释放互斥锁
	pthread_mutex_destroy(&mutex);

	//释放条件变量
	pthread_cond_destroy(&cond);

	return 0;
}

 多个生产者和多个消费者时的情况：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

typedef struct node
{
   int data;
   struct  node *next;
}Node;

//定义全局节点
Node * head = NULL;

//定义互斥量
pthread_mutex_t mutex;

//定义全局变量
pthread_cond_t cond;

//生产者者线程
void * Produce(void * arg)
{
   int n = *(int *)arg;
   Node * pnode = NULL;
   while (1)
   {
      //申请空间
      pnode = (Node*)malloc(sizeof(Node));
      if (pnode == NULL)
      {
         perror("malloc error\n");
         exit(-1);
      }
      
      pnode->data = rand() % 1000;
      printf("Produce data[%d] = [%d]\n", n, pnode->data);

      //共享资源位置加锁
      pthread_mutex_lock(&mutex);

      //头插法 
      pnode->next = head;
      head = pnode;

      //解锁
      pthread_mutex_unlock(&mutex);

      //发送信号
      pthread_cond_signal(&cond);

      sleep(rand() % 3);
   }
}

//消费者线程
void * Custom(void * arg)
{
   int n = *(int *)arg;
   Node * pnode = NULL;
   while (1)
   {
      //共享资源位置加锁
      pthread_mutex_lock(&mutex);

      //如果head为空阻塞等待非空的情况
      if (head == NULL)
      {
         //条件不满足, 阻塞线程，并解锁
         //条件满足（生产者发送phread_cond_signal), 通知阻塞的线程解除阻塞并加锁, 开始工作
         //和互斥量一起使用，如果收到signal信号，可能有多个信号收到信号，只有一个线程可以获得互斥量，其他线程进入阻塞状态
         pthread_cond_wait(&cond, &mutex);
      }
      
      //一个线程收到singnal信号后获得互斥锁将往下执行 会把head消费掉
      //如果不加以判断 当另外一个线程获得互斥锁之后再往下执行就会出现死机的状态
      //加以判断时需要注意，要将互斥量解锁，因为pthread_cond_wait将互斥量进行了加锁，如果不解锁，将进入阻塞。
      if (head == NULL)
      {
         pthread_mutex_unlock(&mutex);
         continue;
      }
      
      pnode = head;
      printf("Custom data[%d] = [%d]\n", n, pnode->data);
      head = head->next;

      //解锁
      pthread_mutex_unlock(&mutex);

      free(pnode);
      pnode = NULL;

      sleep(rand() % 3);
   }
   
}

int main()
{
   //初始化互斥量
   pthread_mutex_init(&mutex, NULL);

   //初始化全局变量
   pthread_cond_init(&cond, NULL);

   pthread_t thread[5], thread2[5];
   int arr[5];
   for (int i = 0; i < 5; i++)
   {
      arr[i] = i;
      int ret = pthread_create(&thread[i], NULL, Produce, &arr[i]);
      if (ret != 0 )
      {
         printf("thread creat error : [%s]", strerror(ret));
         return -1;
      }
      ret = pthread_create(&thread2[i], NULL, Custom, &arr[i]);
      if (ret != 0 )
      {
         printf("thread creat error : [%s]", strerror(ret));
         return -1;
      }
   }

   //回收子线程
   for (int  i = 0; i < 5; i++)
   {
      pthread_join(thread[i], NULL);
      pthread_join(thread2[i], NULL);
   }
   
   //销毁互斥量
   pthread_mutex_destroy(&mutex);

   //销毁全局变量
   pthread_cond_destroy(&cond);

   return 0;
}

4 信号量

 1 信号量介绍

         信号量相当于多把锁, 可以理解为是加强版的互斥锁

2 相关函数

//定义信号量 
sem_t sem;
int sem_init(sem_t *sem, int pshared, unsigned int value);  
  • 函数描述: 初始化信号量
  • 函数参数:

sem: 信号量变量

pshared: 0表示线程同步, 1表示进程同步

value: 最多有几个线程操作共享数据

  • 函数返回值:成功返回0, 失败返回-1, 并设置errnor
int sem_wait(sem_t *sem);
  • 函数描述: 调用该函数一次, 相当于sem--, 当sem为0的时候, 引起阻塞
  • 函数参数: 信号量变量
  • 函数返回值: 成功返回0, 失败返回-1, 并设置errno
int sem_post(sem_t *sem);
  • 函数描述: 调用一次, 相当于sem++
  • 函数参数: 信号量变量
  • 函数返回值: 成功返回0, 失败返回-1, 并设置errno值
int sem_trywait(sem_t *sem);
  • 函数描述: 尝试加锁, 若失败直接返回, 不阻塞
  • 函数参数: 信号量变量
  • 函数返回值: 成功返回0, 失败返回-1, 并设置errno值
int sem_destroy(sem_t *sem);
  • 函数描述: 销毁信号量
  • 函数参数: 信号量变量
  • 函数返回值: 成功返回0, 失败返回-1, 并设置errno值

3 信号量代码片段:

//使用信号量实现生产者和消费者模型
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

/*
信号量的使用需要定义两个信号量 sem_t producer consumer 生产者和消费者
producer为同时运行线程的个数 默认大于0 consumer默认为0
生产者在执行生产之前需要调用sem_wait(&producer)进行阻塞 相当于producer-- 同时通知
消费者进行消费 调用sem_post(&consumer) 相当于 consumer++

消费者进行消费时，首先调用sem_wait(&consumer) 进行阻塞 收到sem_post(&consumer)信号时解除阻塞 相当于consumer--
并且需要发送em_post(&producer)同时生产者继续生成 相当于producer++
*/

//定义信号量
sem_t sem_producer;
sem_t sem_consumer;

typedef struct node
{
	int data;
	struct node *next;
}NODE;

NODE *head = NULL;

//生产者线程
void *producer(void *arg)
{
	NODE *pNode = NULL;
	while(1)
	{
		//生产一个节点
		pNode = (NODE *)malloc(sizeof(NODE));
		if(pNode==NULL)
		{
			perror("malloc error");
			exit(-1);
		}
		pNode->data = rand()%1000;
		printf("P:[%d]\n", pNode->data);

		//加锁
		sem_wait(&sem_producer);	//相当于++

		pNode->next = head;
		head = pNode;

		//解锁
		sem_post(&sem_consumer);	//相当于--
		sleep(rand()%3);
	}
}


//消费者线程
void *consumer(void *arg)
{
	NODE *pNode = NULL;
	while(1)
	{
		//加锁
		sem_wait(&sem_consumer);	//相当于++

		printf("C:[%d]\n", head->data);	
		pNode = head;
		head = head->next;

		//解锁
		sem_post(&sem_producer);	//相当于--

		free(pNode);
		pNode = NULL;

		sleep(rand()%3);
	}
}

int main()
{
	int ret;
	pthread_t thread1;
	pthread_t thread2;

	//初始化信号量 0代表线程 1代表进程
	sem_init(&sem_producer, 0, 5);
	sem_init(&sem_consumer, 0, 0);

	//创建生产者线程
	ret = pthread_create(&thread1, NULL, producer, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}

	//创建消费者线程
	ret = pthread_create(&thread2, NULL, consumer, NULL);
	if(ret!=0)
	{
		printf("pthread_create error, [%s]\n", strerror(ret));
		return -1;
	}

	//等待线程结束
	pthread_join(thread1, NULL);
	pthread_join(thread2, NULL);

	//销毁信号量
	sem_destroy(&sem_producer);
	sem_destroy(&sem_consumer);

	return 0;
}

没有网名L
关注
专栏目录
[Linux系统编程]线程同步（五）
weixin_44972997的博客
04-17 2940
距离上一次利用高并发技术实现360度行车记录仪功能已经过去半年了。开始写一系列关于系统编程和网络编程内容进行总结。
【Linux系统编程】线程同步
qq_59084325的博客
09-07 1674
【Linux系统编程】线程同步（超详细）
不属于linux编程下线程同步,Linux网络编程面试--多线程同步
weixin_39788572的博客
05-07 767
Linux网络编程面试--多线程同步主要有以下几种同步方式：1.线数据分离为每个线程准备一套数据，线程之间彼此独立，没有读写竞争。2.环形缓冲区如果是一个数据队列，两个线程分别读写，则可以用环形缓冲区来同步。维护两个变量，写偏移量和读偏移量(1)如果队列长度为N，读写偏移量为N-1,则下一次偏移量为0，如此递增----环形(2)如果读偏移P大于写偏移Q则可以读取P-->N-1-->Q之...
Linux多线程编程
C_Trip的博客
11-19 3715
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
Linux多线程 | 线程同步
大柳_的博客。
05-28 1330
文章目录前言主要介绍四种常用的线程同步方式以及相关的函数接口。一、线程同步二、同步方法1.互斥锁2.信号量3.条件变量4.读写锁总结 前言 主要介绍四种常用的线程同步方式以及相关的函数接口。 提示：以下是本篇文章正文内容，下面案例可供参考 一、线程同步 线程同步指的是当一个线程在对某个临界资源进行操作时，其他线程都不可以对这个资源进行操作，直到该线程完成操作，其他线程才能操作，也就是协同步调，让线程按预定的先后次序进行运行。线程同步的方法有四种：互斥锁、信号量、条件变量、读写锁。 二、同步方法 1.互斥锁
Linux多线程（2）-线程间同步的5种方式，一次性说清楚！
嵌入式Linux开发从业者，立志做一名优秀的博客输出者！
03-23 1543
这里都是一些个人血和泪的经验~1）锁的粒度太大，容易出现很多线程阻塞等待锁的情况，导致程序并发性差而如果锁的粒度太细，过度的锁开销会使系统性能受到影响，代码变的复杂，所以要找到一个平衡2）在程序开发中，写完lock之后，就要条件反射一般，将unlock写好，防止之后忘记3）在函数内进行lock之后，一定要谨防函数直接return的情况，return 之前要释放锁，否则下次拿锁会出现死锁的情况。4）带锁的线程，在使用pthread_cancle强制取消线程时，要对锁进行处理，详情可见。
linux线程同步的方法
靑い空゛
04-13 5406
Linux 线程同步的三种方法 线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 一、互斥锁(mutex) 通过锁机制实现线程间的同步。 1. 初始化锁: 在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。 静态分配：...
Linux和windows进程同步与线程同步那些事儿（三）： Linux线程同步详解示例
Mr.Sugarcane
01-10 1056
Linux线程同步
Linux和windows进程同步与线程同步那些事儿（二）： windows线程同步详解示例
Mr.Sugarcane
01-09 1253
windows线程同步详解和代码示例
Linux系统编程 —线程同步概念
码到成功
10-16 886
##同步概念 同步，指对在一个系统中所发生的事件之间进行协调，在时间上出现一致性与统一化的现象。 但是，对于不同行业，对于同步的理解略有不同。比如：设备同步，是指在两个设备之间规定一个共同的时间参考；数据库同步，是指让两个或多个数据库内容保持一致，或者按需要部分保持一致；文件同步，是指让两个或多个文件夹里的文件保持一致，等等。 但是，在软件编程或者通信行业中所说的同步与生活中大家印象中的同步概念略有差异。“同”字应是指协同、协助、互相配合。主旨在协同步调，按预定的先后次序运行。注意，这里是指按照预定次序执行
Linux系统下的多线程编程入门.pdf
12-20
本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程概念 多线程是指在一个进程中可以同时执行多个独立的代码段，每个代码...
linux 操作系统 多线程编程 经典同步算法--读者写者问题
07-06
有读者和写者两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。...
嵌入式鸿蒙系统开发语言与开发方法分析
嵌入式技术开发
09-10 1034
可复用的UI单元，可组合其它组件，如上述被@Component装饰的struct Hello。UI描述:声明式的方法来描述UI的结构，例如build()方法中的代码块。
linux 使用SSH密钥配置免密登录
最新发布
Johnny's Lab
09-13 243
在你的本地机器上生成一个SSH密钥对。如果你已经有一个，你可以跳过这一步。如果你需要在多台主机之间配置免密登录，你可以重复第2步和第3步，为每台远程主机添加你的公钥。注意：在进行这些操作时，请确保你有对远程主机的适当访问权限，并且你的SSH服务已经启动。在Linux中，使用SSH密钥对来在多台主机之间配置免密登录。将公钥进行分发，如果没有这个命令，可以手动进行操作，多台主机分别操作。先使用一台主机生成密钥对，如果root权限被禁止，请使用其他用户。在终端中运行以下命令，将你的公钥复制到远程主机。
【观察】戴尔AI算力加速服务器“焕新上市”，打通AI落地行业“最后一公里”...
申耀的科技观察
09-12 348
今天，在人工智能的推动下，企业数智化转型已进入规模化“倍增创新”的阶段，尤其是以大模型为代表的AI技术加速演进，以及应用场景的不断拓展加深，都让各类AI创新应用如雨后春笋般涌现，并加速惠及千行万业。但与此同时，AI大模型的火热登场，也引爆了智能算力的需求。根据中国信通院发布的《中国算力发展指数白皮书（2023年）》显示，在目前的算力规模中，通用算力规模占比达74%，智能算力规模占比达25%，同比增...
高防服务器的优势与劣势分析
2403_86998484的博客
09-10 243
高防服务器通过持续监控和快速响应网络安全事件，极大地减少了由于网络攻击导致的服务中断，从而确保了业务的连续性。在网络安全威胁日益增加的今天，保障数据的安全是企业信誉的重要部分。高防服务器通常需要更多的资源来维护其高级的安全功能，包括硬件和软件的配置。这使得高防服务器的成本远高于标准服务器，可能需要更多的初期和持续的投资。高防服务器要求专业的知识和技能来进行正确的配置和维护。为了实现强大的安全防护，某些安全措施可能会对服务器的性能产生影响，例如，高强度的流量过滤可能会导致处理速度变慢，影响用户体验。
搭建一个本地 SMTP 服务器
FHKHH的博客
09-08 596
由于 SMTP 服务器的开放端口和安全性问题，许多现代邮件服务器不再允许直接通过连接到标准的 25 端口发送邮件，尤其是未经认证的用户。因此，许多公共电子邮件服务商如 Gmail、Yahoo 等也禁用了这种方式，转而要求使用更安全的加密连接，如通过 SSL/TLS 连接发送邮件。不过，如果你有权限使用某个 SMTP 服务器（比如你自己公司的邮件服务器或本地服务器），你可以联系你的邮件服务器管理员获取服务器的名称和端口号，确保你可以通过 Telnet 进行实验。
Linux多线程编程同步技术详解
"《Linux多线程编程手册》是一本深入讲解Linux系统下多线程编程的实用指南，由Sun Microsystems, Inc.发布，旨在为Linux工程师提供详细的同步技术参考。本书详细阐述了如何在Linux环境中有效地设计、实现和管理多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值