linux之线程同步

已于 2023-05-17 12:12:50 修改
阅读量210 收藏
点赞数
分类专栏： linux 并发编程 操作系统 文章标签： linux 运维 服务器
于 2023-05-17 12:12:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjfdsklfdkfksd/article/details/130712041
版权

1. 互斥锁

定义锁：
pthread_mutex_t  

初始化锁函数：
int pthread_mutex_init(pthread_mutex_t* mutex,pthread_mutexattr_t* attr);       
第一个参数是定义的互斥锁的地址，第二个参数是锁的属性，一般传NULL
互斥锁的属性在创建锁的时候指定，
有四个值可供选择：
* PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
* PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
* PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样保证当不允许多次加锁时不出现最简单情况下的死锁
* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争
也可以使用pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

加锁函数：
int pthread_mutex_lock(pthread_mutex_t* mutex); //加锁失败就会阻塞或 
int pthread_mutex_trylock(pthread_mutex_t* mutex); //尝试加锁，成功返回0，失败则会返回错误码，不阻塞

解锁函数：
int pthread_mutex_unlock(pthread_mutex_t* mutex); 

销毁锁函数：
int pthread_mutex_destroy(pthread_mutex_t* mutex);

2. 数据库连接池

server

#include "/freecplus/_freecplus.h"
#include "/freecplus/db/oracle/_ooci.h"
/*将socket发来的数据存入数据库*/

pthread_mutex_t mutexs[100];  // 用于数据库连接池的锁。
connection conns[100];  // 数据库连接池。
bool initconns();  // 初始化数据库连接池。
connection* getconn(); // 从连接池中获取一个数据库连接。
void freeconn(connection* in_conn); // 释放数据库连接。
void freeconns(); // 释放数据库连接池。
void* pthmain(void* arg);
CTcpServer TcpServer;   // 创建服务端对象。
std::vector<long> vpthid;    // 存放线程id的容器。
void mainexit(int sig);  // 信号2和15的处理函数。

// 线程清理函数。
void pthmainexit(void* arg);

CLogFile logfile;

int main(int argc, char* argv[])
{
	signal(2, mainexit);  
	signal(15, mainexit);  // 捕获信号2和15

	logfile.Open("/tmp/serverdb.log", "a+");

	if (TcpServer.InitServer(5858) == false) // 初始化TcpServer的通信端口。
	{
		logfile.Write("TcpServer.InitServer(5858) failed.\n"); return -1;
	}


	if (initconns() == false)  // 初始化数据库连接池。
	{
		logfile.Write("initconns() failed.\n"); return -1;
	}

	while (true)
	{
		if (TcpServer.Accept() == false)   // 等待客户端连接。
		{
			logfile.Write("TcpServer.Accept() failed.\n"); return -1;

		}

		logfile.Write("客户端(%s)已连接。\n", TcpServer.GetIP());

		pthread_t pthid;

		if (pthread_create(&pthid, NULL, pthmain, (void*)(long)TcpServer.m_connfd) != 0)
		{
			logfile.Write("pthread_create failed.\n"); return -1;
		}
		vpthid.push_back(pthid);   // 把线程id保存到vpthid容器中。
	}

	return 0;
}

void* pthmain(void* arg)
{
	pthread_cleanup_push(pthmainexit, arg);  // 设置线程清理函数。

	pthread_detach(pthread_self());  // 分离线程。

	pthread_setcanceltype(PTHREAD_CANCEL_DISABLE, NULL);  // 设置取消方式为立即取消。

	int sockfd = (int)(long)arg;  // 与客户端的socket连接。

	int ibuflen = 0;
	char strbuffer[1024];  // 存放数据的缓冲区。

	while (true)
	{
		memset(strbuffer, 0, sizeof(strbuffer));
		if (TcpRead(sockfd, strbuffer, &ibuflen, 300) == false) break; // 接收客户端发过来的请求报文。
		logfile.Write("接收：%s\n", strbuffer);
		connection* conn = getconn();  // 获取一个数据库连接。

		// 处理业务
		sleep(2);
		freeconn(conn);  // 释放一个数据库连接。
		strcat(strbuffer, "ok");      // 在客户端的报文后加上"ok"。

		logfile.Write("发送：%s\n", strbuffer);

		if (TcpWrite(sockfd, strbuffer) == false) break;     // 向客户端回应报文。
	}
	logfile.Write("客户端已断开。\n");    // 程序直接退出，析构函数会释放资源。

	pthread_cleanup_pop(1);
	pthread_exit(0);
}

// 信号2和15的处理函数。
void mainexit(int sig)
{
	logfile.Write("mainexit begin.\n");
	// 关闭监听的socket。
	TcpServer.CloseListen();

	// 取消全部的线程。
	for (int ii = 0; ii < vpthid.size(); ii++)
	{
		logfile.Write("cancel %ld\n", vpthid[ii]);
		pthread_cancel(vpthid[ii]);
	}

	// 释放数据库连接池。
	freeconns();
	logfile.Write("mainexit end.\n");

	exit(0);
}


// 线程清理函数。
void pthmainexit(void* arg)
{
	logfile.Write("pthmainexit begin.\n");
	// 关闭与客户端的socket。
	close((int)(long)arg);

	// 从vpthid中删除本线程的id。
	for (int ii = 0; ii < vpthid.size(); ii++)
	{
		if (vpthid[ii] == pthread_self())

		{

			vpthid.erase(vpthid.begin() + ii);

		}

	}

	logfile.Write("pthmainexit end.\n");
}


// 初始化数据库连接池。
bool initconns()
{
	for (int ii = 0; ii < 10; ii++)
	{
		if (conns[ii].connecttodb("scott/tiger", "Simplified Chinese_China.ZHS16GBK") != 0)
		{
			logfile.Write("connect database failed.\n%s\n", conns[ii].m_cda.message); return false;
		}
	}

	for (int ii = 0; ii < 10; ii++) pthread_mutex_init(&mutexs[ii], NULL);

	return true;
}



// 从连接池中获取一个数据库连接。
connection* getconn()
{
	for (int ii = 0; ii < 10; ii++)
	{
		if (pthread_mutex_trylock(&mutexs[ii]) == 0)
		{
			logfile.Write("get a conn[%d] ok.\n", ii);
			return &conns[ii];
		}

	}
    /*没有获取到连接  新建连接*/
	return NULL;
}


// 释放数据库连接。
void freeconn(connection* in_conn)
{

	for (int ii = 0; ii < 10; ii++)
	{
		if (in_conn == &conns[ii]) pthread_mutex_unlock(&mutexs[ii]);
	}
}



// 释放数据库连接池。
void freeconns()
{
	for (int ii = 0; ii < 10; ii++)
	{
		conns[ii].disconnect(); pthread_mutex_destroy(&mutexs[ii]);
	}
}

client.cpp

#include "_freecplus.h"

int main(int argc, char* argv[])
{
	printf("pid=%d\n", getpid());

	CTcpClient TcpClient;   // 创建客户端的对象。

	if (TcpClient.ConnectToServer("172.21.0.3", 5858) == false) // 向服务端发起连接请求。
	{
		printf("TcpClient.ConnectToServer(\"172.21.0.3\",5858) failed.\n"); return -1;
	}

	char strbuffer[1024];    // 存放数据的缓冲区。

	for (int ii = 0; ii < 50; ii++)   // 利用循环，与服务端进行5次交互。
	{
		memset(strbuffer, 0, sizeof(strbuffer));
		snprintf(strbuffer, 50, "(%d)这是第%d个超级女生，编号%03d。", getpid(), ii + 1, ii + 1);
		printf("发送：%s\n", strbuffer);
		if (TcpClient.Write(strbuffer) == false) break;    // 向服务端发送请求报文。

		memset(strbuffer, 0, sizeof(strbuffer));
		if (TcpClient.Read(strbuffer, 20) == false) break;  // 接收服务端的回应报文。
		printf("接收：%s\n", strbuffer);
		sleep(5);
	}
	// 程序直接退出，析构函数会释放资源。
}

3. 条件变量

3.1 初始化条件变量

初始化条件变量的方式有两种，一种是直接将 PTHREAD_COND_INITIALIZER 赋值给条件变量，例如：

pthread_cond_t myCond = PTHREAD_COND_INITIALIZER;

借助 pthread_cond_init() 函数初始化条件变量，语法格式如下：

int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr);

3.2 阻塞当前线程，等待条件成立

int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);
int pthread_cond_timedwait(pthread_cond_t* cond, pthread_mutex_t* mutex, const struct timespec* abstime);

3.3 解除线程的“阻塞”状态

int pthread_cond_signal(pthread_cond_t* cond);
int pthread_cond_broadcast(pthread_cond_t* cond);

3.4 销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_wait发生了什么？

  1. 释放了互斥锁
  2. 等待条件
  3. 条件被触发
  4. 给互斥锁被加锁
#include <pthread.h>
#include <signal.h>
#include <unistd.h>
#include <stdio.h>

pthread_cond_t    myCond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t   mut = PTHREAD_MUTEX_INITIALIZER;

void* th1(void* arg)
{
    while(true)
    {   
        pthread_mutex_lock(&mut);
        pthread_cond_wait(&myCond, &mut);//等待条件
        printf("线程一被唤醒\n");
        pthread_mutex_unlock(&mut);
    }
}

void* th2(void* arg)
{
    while(true)
    {
        pthread_mutex_lock(&mut);
        pthread_cond_wait(&myCond, &mut);
        printf("线程二被唤醒\n");
        pthread_mutex_unlock(&mut);
    }
}

void func(int sig)
{
    pthread_cond_signal(&myCond);
    //pthread_cond_broadcast(&myCond);
}

int main()
{
    signal(15, func);

    pthread_t t1,t2;
    pthread_create(&t1, NULL, th1, NULL);
    pthread_create(&t2, NULL, th2, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_cond_destroy(&myCond);
    pthread_mutex_destroy(&mut);

    return 0;
}

4. 生产者消费者模型

生产消费者模型

// 本程序演示用互斥锁和条件变量实现高速缓存
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <vector>

using namespace std;

int mesgid = 1;  //消息的计数器
// 缓存消息的结构体。
struct st_message
{
	int  mesgid;
	char message[1024];
} stmesg;

std::vector<struct st_message> vcache;  // 用vector容器做缓存

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;      // 声名并初始化条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;   // 声名并初始化互斥锁

// 消费者、出队线程主函数
void* outcache(void* arg)
{
	struct st_message stmesg;

	while (true)
	{		    
		pthread_mutex_lock(&mutex);  // 加锁
		// 如果缓存为空，等待
        // 条件变量虚假唤醒  用if的话会有问题
		while (vcache.size() == 0)
		{
			pthread_cond_wait(&cond, &mutex);
		}
        // 从缓存中获取第一条记录，然后删除该记录
        memcpy(&stmesg, &vcache[0], sizeof(struct st_message)); // 内存拷贝
		vcache.erase(vcache.begin());
		pthread_mutex_unlock(&mutex);  // 解锁
		// 以下是处理业务的代码
		printf("phid=%ld,mesgid=%d\n", pthread_self(), stmesg.mesgid);
		usleep(100);
	}
}

// 生产者、把生产的数据存入缓存
//void* incache(void* arg)
void incache(int arg)
{
    struct st_message stmesg;
    memset(&stmesg, 0, sizeof(struct st_message));
    stmesg.mesgid = mesgid++;
    pthread_mutex_lock(&mutex);  // 加锁。
    // 生产数据，放入缓存。
    vcache.push_back(stmesg);    // 内存拷贝。
    pthread_mutex_unlock(&mutex); // 解锁
    //pthread_cond_broadcast(&cond);  // 触发条件，激活全部的线程。
    pthread_cond_signal(&cond);
}

int main()
{
	signal(15, incache);  //接收15的信号，调用生产者函数。

	pthread_t thid1, thid2, thid3, thid4;
	pthread_create(&thid1, NULL, outcache, NULL);
	pthread_create(&thid2, NULL, outcache, NULL);
	pthread_create(&thid3, NULL, outcache, NULL);
	pthread_join(thid1, NULL);
	pthread_join(thid2, NULL);
	pthread_join(thid3, NULL);

	return 0;
}

注意

  1. 条件触发要写在解锁之后
    pthread_mutex_unlock(&mutex); // 解锁
    pthread_cond_broadcast(&cond);  // 触发条件，激活全部的线程。
  1. 持有锁的时间越短越好

5. 信号量

信号量是一个整数计数器,其数值可以用于标识空闲临界资源的数量。
当有进程释放资源时,信号量增加,表示可用资源数增加；当有进程申请到资源时，信号量减少，表示可用资源数减少；

  • 1、sem_init
    函数声明：int sem_init(sem_t *sem, int pshared, unsigned int value);
    创建信号量，初始化由sem指向的信号对象，设置它的共享选项，并给它一个初始的整数值；pshared控制信号量的类型，如果值为0，就表示这个信号量是当前进程的局部信号量，在当前进程的多个线程之间共享，否则信号量就可以在多个进程之间共享；value为sem的初始值

    返回值：调用成功时返回0，失败返回-1。

  • 2、sem_wait
    函数声明：int sem_wait(sem_t *sem);
    用于以原子操作的方式将信号量的值减1。sem指向的对象是sem_init调用初始化的信号量

    返回值：调用成功返回0，失败返回-1

  • 3、sem_post
    函数声明：int sem_post(sem_t *sem);
    用于以原子操作的方式将信号量的值加1。sem指向的对象是sem_init调用初始化的信号量。
    返回值：调用成功返回0，失败返回-1

  • 4、sem_destroy
    函数声明：int sem_destroy(sem_t *sem);
    用于对用完的信号量的清理。只有用sem_init初始化的信号量才能用sem_destroy销毁
    返回值：调用成功返回0，失败返回-1。

信号量实现生产者消费者模型

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <vector>
#include <semaphore.h>

using namespace std;

int mesgid = 1;  // 消息的记数器。

// 缓存消息的结构体。
struct st_message
{
	int  mesgid;
	char message[1024];
} stmesg;


std::vector<struct st_message> vcache;  // 用vector容器做缓存。

sem_t sem;  // 声明信号量。
pthread_mutex_t mutex;   // 声名并初始化互斥锁。


// 消费者、出队线程主函数。
void* outcache(void* arg)
{
	struct st_message stmesg;

	while (true)
	{
		while (vcache.size() == 0)
		{
			sem_wait(&sem);  // 如果缓存中没有数据，等待信号。
			printf("%ld wait ok.\n", pthread_self());
		}

		pthread_mutex_lock(&mutex);  // 加锁。

		if (vcache.size() == 0) // 判断缓存中是否有数据。
		{
			pthread_mutex_unlock(&mutex);
			continue;  // 解锁，continue
		}

		// 从缓存中获取第一条记录，然后删除该记录。
		memcpy(&stmesg, &vcache[0], sizeof(struct st_message));
		vcache.erase(vcache.begin());
		pthread_mutex_unlock(&mutex);  //解锁

		// 以下是处理业务的代码。
		printf("phid=%ld,mesgid=%d\n", pthread_self(), stmesg.mesgid);
		usleep(100);
	}
}

// 生产者、把生产的数据存入缓存。
void incache(int sig)
{
	struct st_message stmesg;
	memset(&stmesg, 0, sizeof(struct st_message));

	pthread_mutex_lock(&mutex);  // 加锁。

	// 生产数据，放入缓存。
	stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
	stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
	stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
	stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
	stmesg.mesgid = mesgid++; vcache.push_back(stmesg);
	stmesg.mesgid = mesgid++; vcache.push_back(stmesg);

	pthread_mutex_unlock(&mutex); // 解锁。

	sem_post(&sem);  // 信号加1。
	sem_post(&sem);  // 信号加1。
	sem_post(&sem);  // 信号加1。
	sem_post(&sem);  // 信号加1。
	sem_post(&sem);  // 信号加1。
	sem_post(&sem);  // 信号加1。
}

int main()
{
	signal(15, incache);  // 接收15的信号，调用生产者函数。

	sem_init(&sem, 0, 0);  // 初始化信号量。
	pthread_mutex_init(&mutex, NULL); // 初始化互斥锁。

	pthread_t thid1, thid2, thid3;
	pthread_create(&thid1, NULL, outcache, NULL);
	pthread_create(&thid2, NULL, outcache, NULL);
	pthread_create(&thid3, NULL, outcache, NULL);

	pthread_join(thid1, NULL);
	pthread_join(thid2, NULL);
	pthread_join(thid3, NULL);

	return 0;
}

6. 读写锁

互斥锁只有加锁和不加锁两种状态，同一时间只能有一个线程加锁。
读写锁可以有三种状态:读模式下加锁，写模式下加锁和不加锁
读写锁的特点：

  1. 如果某线程申请了读锁，其他线程可以再申请读锁，但不能申请写锁
  2. 如果某线程申请了写锁，其他线程既不能申请读锁，也不能申请写锁
    读写锁适合对数据的读比写次数多的情况。

7. 自旋锁

自旋锁是一种基于忙等待的锁，它在等待锁的过程中不会阻塞线程，而是使用循环不停地检查锁是否可用。如果锁被其他线程占用，当前线程就会一直循环等待，直到锁被释放为止。

自旋锁的优点是等待锁的线程不会被阻塞，因此在锁的占用时间很短的情况下，自旋锁的性能比较高。另外，自旋锁一般比互斥锁的实现更加简单，因为它不需要使用系统调用来挂起和恢复线程。

不过自旋锁也有一些缺点。首先，如果锁的占用时间很长，自旋锁会导致线程一直循环等待，浪费 CPU 资源。其次，自旋锁只适用于单核 CPU 或者多核 CPU 上锁的线程数比较少的情况，因为在多核 CPU 上，如果一个线程一直占用锁，其他线程就会一直循环等待，导致 CPU 资源的浪费和性能下降。

wjfdsklfdkfksd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux之线程同步一
Junds0的博客
06-28 2070
由于同一进程中的多个线程共享全局数据，因此，在多线程编程中如果一个线程对全局变量A进行修改时，而此时又有一个线程正在读取该变量，则有可能会出现数据的不一致性。本关将介绍一种线程同步方式-互斥锁。本关任务：学会使用互斥锁来实现线程间的同步。 第2关：自旋锁 在上一关中，我们介绍了如何使用互斥锁来同步线程，本关将介绍Linux系统中的另一种锁，它就是自旋锁。本关任务：学会使用自旋锁来实现线程间的同步。 第3关：条件变量 在以上两关中，我们介绍了如何互斥锁和自旋锁的使用方式，并且使用互斥锁和自旋锁来同步线程，本关
Linux之线程同步
zdlynj的博客
03-19 1883
此时我们会发现唤醒这三个线程时具有明显的顺序性，因为这些线程启动时默认都会在该条件变量下去等待，而我们每次都唤醒的是在当前条件变量下等待的头部线程，当该线程执行完代码后会继续排到等待队列的尾部进行等待。这是因为如果个别线程的竞争力特别强，每次都能够申请到锁，但申请到锁之后什么也不做，所以在我们看来这个线程就一直在申请锁和释放锁，那么它就可以一直抢票。为了解决这个问题，我们增加一个限制：当一个线程释放锁后，这个线程不能立马再次申请锁，该线程必须排到这个锁的资源等待队列的最后。3、唤醒线程去访问临界资源。
educoder : Linux之线程同步二(1)
LIAO_sir的博客
11-13 3889
信号量
linux线程同步
longlong068的博客
07-21 332
Linux线程线程框架一、线程概念**线程的概念**：线程和进程的区别：二、线程共享资源和非共享资源线程共享资源：线程非共享资源：三、线程的优缺点优点：缺点：四、线程控制函数获取线程ID pthread_self创建线程pthread_create线程退出函数pthread_exit线程回收pthread_join线程分离pthread_detach杀死进程pthread_cancelpthread_equal五、线程属性梗概线程属性初始化设置属性分离态线程使用注意事项线程同步框架一、线程同步的一些概念1.
Linux线程同步
C语言实战技术
03-06 2913
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？一起停止？我当年听说线程同步这个词的时候，也是一头雾水。 在人们的日常生活中的锁大概有两种：一种是不允许访问；另一种是资源忙，同一时间只允许一个使用者占用，其它使用者必须要等待。 1...
linux之线程同步一-.zip
05-23
在Linux操作系统中，线程同步是多线程编程中的一个重要概念，它确保了多个线程在访问共享资源时能够...通过学习“linux之线程同步一”这个资料包，你将深入理解Linux线程同步的核心概念，并能够熟练运用到实际开发中。
11.Linux线程同步
01-06
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？...
linux之线程同步一.doc
05-01
### Linux中的线程同步 #### 一、引言 在多线程编程中，线程同步是至关重要的一环。尤其在Linux环境下，由于其广泛应用于服务器领域，...随着并发编程的日益普及，掌握线程同步技术已成为软件工程师的基本技能之一。
linux之线程同步的概要介绍与分析
05-01
学习Linux线程同步，推荐查阅以下资源： - **书籍**：《Advanced Programming in the UNIX Environment》（APUE）一书的相关章节。 - **文档**：Linux man pages 中关于`pthread`系列函数的详细说明。 - **实践项目*...
Linux 定时任务
flash的博客
08-14 276
在Linux系统中，cron是一个广泛使用的定时任务工具，允许用户安排周期性执行的任务（脚本或命令）。cron守护进程（crond）会读取配置文件（通常位于/etc/crontab），并根据这些配置文件中指定的时间规则来执行相应的任务。
linux：有关目录、链接文件的函数 Makefil、gdb的使用
T66656的博客
08-15 613
功能:根据用户id到/etc/passwd文件下解析获得结构体信息参数:uid:用户id返回值:成功返回id对应用户的信息失败返回NULLpasswd结构体的定义通常如下所示。
linux开启RNDIS，实现虚拟网卡
轩辕霸天L
08-15 265
首先要 `make clean`，清空之前的编译结果。
linux为QT程序创建桌面应用
王尼莫的博客
08-12 205
【代码】linux为QT程序创建桌面应用。
linux进程
lijiaweixx的博客
08-12 391
设计程序动态生成两个进程分别向相同文件写入不同数据时，需注意父子进程操作同一文件，可通过。Linux 中的 PCB（process control block）进程的主要作用是实现并发，提高系统资源的利用率和系统的处理能力。内核的主要功能之一是完成进程调度，宏观上并行，微观上串行。创建进程，在不同的进程分支中通过。获取进程 ID 及时间来标识。
PX4-Autopolite linux环境下源码编译中遇到的一些问题及相应解决办法
kirioo的博客
08-12 946
PX4源码编译
Linux Bridge VLAN
qq_42477169的博客
08-15 522
H3CH3C的S5120系列交换机锐捷：CISCO：Arista：中兴：web配置改为桥接后会激活 CPU 的临时软桥接，是传统的 linux bridge ，此时 hardware offload 不会介入，所有的数据包处理通过 CPU 转发华硕ASUS：RT-AX53U。
Linux 内核中的并发与竞争
小灰灰的博客
08-15 29
并发是指多个任务在同一时间段内进行的能力，允许它们在逻辑上同时执行，而不一定是在物理上并行处理。并发的关键在于任务的调度与管理，使得系统能够高效利用资源。竞争是指多个任务在访问共享资源时的争夺状态，当它们试图同时读取或修改同一资源时，会导致错误或不一致的结果。
06_Linux中如何让程序重启后自动启动
最新发布
qq_40681630的博客
08-15 196
假设你的应用程序位于 /opt/myapp 目录下，并且有一个名为 myapp 的可执行文件。我们将创建一个名为 myapp.service 的文件，以定义如何启动、停止和服务的行为。[Unit][Service][Install][Unit] 部分Description：服务的描述。After：定义此服务依赖于哪些其他服务。在这里，我们指定 network.target，意味着服务将在网络准备好之后启动。[Service] 部分Type：定义服务的启动类型。
linux（debian）迁移home到其他物理盘并扩容——————附带详细步骤
韩江雪de 小屋
08-12 734
注意：Linux系统使用逻辑卷来模拟物理分区，并在其中保存文件系统。Linux系统会像处理物理分区一样处理逻辑卷，允许你定义逻辑卷中的文件系统，然后将文件系统挂载到虚拟目录上。删除LVM之前创建的物理卷，卷组，逻辑卷时，删除顺序应该与创建时的顺序相反。也就是卸载文件系统，删除逻辑卷，删除卷组，删除物理卷。因为在装debian系统时，home目录和系统目录都在同一个物理盘上（使用LVM安装）。后面新添了物理硬盘，需要做到存储系统和数据的物理硬盘分离。注意：pvcreate定义了用于物理卷的物理分区。
linux之线程同步一头歌
06-28
Linux之线程同步一头歌 线程同步是Linux中非常重要的一个概念，它可以保证多个线程之间的数据访问不会出现冲突，从而保证程序的正确性和稳定性。线程同步的实现方式有很多种，比如互斥锁、条件变量、信号量等等。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值