嵌入式应用开发

同步

---

线程同步

进程同步

互斥

---

线程互斥

互斥锁

信号量

条件变量

文件锁

进程互斥

文件锁

---

#include <stdio.h>
#include <sys/file.h>
#include <unistd.h>

#define FILE_LOCK  "file.lock"

int main(int argc, char *argv[])
{
	int fd = 0;
	int ret = 0;
	char* proc_name =  argv[1];

	while(1)
	{
		fd = open(FILE_LOCK, O_RDONLY|O_CREAT);
		if (fd < 0)
		{
			return -1;
		}

		ret = flock(fd, LOCK_EX);
		if (0 == ret)
		{
			printf("proc %s get clock and sleep for 5s\n", proc_name);
			sleep(5);
			printf("proc %s release clock\n", proc_name);
			flock(fd, LOCK_UN);
		}
		else
		{
			printf("proc %s fail to get lock, return.\n", proc_name);
			close(fd);
			return -1;
		}

		close(fd);
		usleep(1000);
	}

	return 0;
}

信号量

---

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>

//初始化信号量
void sem_init(int semid, int val)
{
	int ret;
	union semun
	{
		int val;			   /* Value for SETVAL */
		struct semid_ds *buf;  /* Buffer for IPC_STAT, IPC_SET */
		unsigned short *array; /* Array for GETALL, SETALL */
		struct seminfo *__buf; /* Buffer for IPC_INFO */
	}semun;

	semun.val = val;
	ret = semctl(semid, 0, SETVAL, semun);
	if (ret < 0)
	{
		perror("semctl error.");
		exit(1);
	}
}
//获取信号量
void sem_p(int semid)
{
	int ret;

	struct sembuf sembuf = {
		.sem_num = 0,
		.sem_op = -1,
		.sem_flg = 0};

	ret = semop(semid, &sembuf, 1);
	if (ret < 0)
	{
		perror("semop error");
		exit(1);
	}
}
//释放信号量
void sem_v(int semid)
{
	int ret;

	struct sembuf sembuf = {
		.sem_num = 0,
		.sem_op = 1,
		.sem_flg = 0};

	ret = semop(semid, &sembuf, 1);
	if (ret < 0)
	{
		perror("semop error");
		exit(1);
	}
}

int main()
{
	int semid;

	//获取信号量key
	semid = semget(6666, 1, IPC_CREAT | 0666);
	if (semid < 0)
	{
		perror("semget error.");
		exit(1);
	}

	//初始化信号量
	sem_init(semid, 1);

	//创建子进程
	fork();
	fork();

	//业务代码，
	while (1)
	{
		sem_p(semid);

		printf("\nproc %d get lock and sleep for 5s", getpid());
		fflush(stdout);
		sleep(5);
		printf("\nproc %d release lock", getpid());
		fflush(stdout);

		sem_v(semid);
	}
}

互斥锁

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

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

int main(void)
{
    int rt = 0;
    int i = 0;
    int fd;
    pthread_mutex_t *mutex;        //互斥对象
    pthread_mutexattr_t mutexattr; //互斥对象属性

    fd = open("/dev/zero", O_RDWR, 0);
    mutex = mmap(0, sizeof(pthread_mutex_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);

    pthread_mutexattr_init(&mutexattr);
    pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED);
    pthread_mutex_init(mutex, &mutexattr);

    rt = fork();

    while (1)
    {
        if (0 == rt)
        {
            pthread_mutex_lock(mutex);
            for (i = 0; i < 5; i++)
            {
                printf("+++\n");
                sleep(1);
            }
            pthread_mutex_unlock(mutex);
            usleep(10);
        }
        else
        {
            pthread_mutex_lock(mutex);
            for (i = 0; i < 5; i++)
            {
                printf("---\n");
                sleep(1);
            }
            pthread_mutex_unlock(mutex);
            usleep(10);
        }
    }
    return (0);
}

通信

---

线程通信

进程通信

信号

管道

共享内存