#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);
//成功时返回消息队列的id,失败时返回EOF
//key和消息队列关联的key IPC_PRIVATE或ftok
//msgflg标志位IPC_CREAT | 0666

int main() 
{
    int msgid;
    key_t key;
    if ((key = ftok(".", 'q') == -1)
    {
        perror("ftok");
        exit(-1);
    }

    if ((msgid = msgget(key, IPC_CREAT | 0666)) <0) 
    {
        perror("msgget");
        exit(-1);
    }
    ....
    return 0;
}

#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msgid, const void *msgp, size t size,
int msgflg);
//成功时返回0,失败时返回-1
//msgid消息队列id
//msgp 消息缓冲区地址
//size 消息正文长度
//msgflg标志位0或IPC_NOWAIT(无空间时是否阻塞)

struct process1_msg
{
    long mtype; // 必须是long
    char mdata[64];
    .....
    // 其他成员
};

typedef struct // 定义一个消息类型
{
    long mtype;
    char mtext[64];
} MSG;
#define LEN (sizeof(MSG) - sizeof(long)) // 正文长度

int main() 
{
    MSG buf;
    ...
    buf.mtype = 100; // 填充消息类型
    fgets(buf.mtext, 64, stdin); // 填充消息正文
    msgsnd(msgid, &buf, LEN, O); // 发送的消息类型长度不包含消息的类型长度
    ...
    return 0;
}

#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msgid, void *msgp, size_t size, long msgtype,
int msgflg);
//成功时返回收到的消息长度,失败时返回-1
//msgid消息队列id
//msgp消息缓冲区地址
//size指定接收的消息长度
//msgtype指定接收的消息类型
//msgflg标志位0或IPCNOWAIT

typedef struct 
{
    long mtype;
    char mtext[64];
}MSG;
#define LEN (sizeof(MSG)-sizeof(long))
int main() 
{
    MSG buf;
    ...
    if (msgrcv(msgid, &buf,LEN, 200, 0) <0)
    {
        perror("msgrcv");
        exit(-1);
    }
    ....
    return 0;
}

#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msgid, int cmd, struct msqid _ds *buf);
//成功时返回0,失败时返回-1
//msgid 消息队列id
//cmd要执行的操作IPC-STAT / IPC-SET / IPC-RMID
//buf存放消息队列属性的地址

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
typedef struct msg
{
        long type;
        char buf[100];
} msg_t;

#define MSG_LEN(x) (sizeof(x) - sizeof(x.type))
#define MSG_TYPE1 100
#define MSG_TYPE2 200

int main(int argv, char **argc)
{
        int msgid;
        key_t key;
        msg_t msg_send, msg_rcv;

        if (argv < 2)
        {
                printf("输入参数错误");
                exit(-1);
        }

        key = ftok(".", 'p');
        if (key < 0)
        {
                perror("ftok");
                exit(-1);
        }

        msgid = msgget(key, IPC_CREAT | 0666);
        if (key < 0)
        {
                perror("msgget");
                exit(-1);
        }

        msg_send.type = MSG_TYPE1; // 另外一个进程改成MSG_TYPE2
        while (1)
        {
            	printf("input>\n");
                fgets(msg_send.buf, 100, stdin);
                msgsnd(msgid, &msg_send, MSG_LEN(msg_send), 0);
                msgrcv(msgid, &msg_rcv, MSG_LEN(msg_rcv), MSG_TYPE2, 0); // 阻塞接收，另外一个进程改成先从队列接收消息，然后fgets()
                printf("process1:%s\n", argc[1], msg_rcv.buf);   
        }
    	
		msgctl(msgid, IPC-RMID, NULL); // 不用了删除消息队列
        return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <semaphore.h>
#include<pthread.h>

typedef struct msg
{
        long type;
        char buf[100];
} msg_t;

#define MSG_LEN(x) (sizeof(x) - sizeof(x.type))
#define MSG_TYPE1 100
#define MSG_TYPE2 200

msg_t msg_send, msg_rcv; // 线程内共享的变量
int msgid;

void *thraed_entery(void *arg);

int main(int argv, char **argc)
{
        key_t key;
        pthread_t a_thread;

        key = ftok(".", 'p');
        if (key < 0)
        {
                perror("ftok");
                exit(-1);
        }

        msgid = msgget(key, IPC_CREAT | 0666);
        if (key < 0)
        {
                perror("msgget");
                exit(-1);
        }

        if (pthread_create(&a_thread, NULL, thraed_entery, NULL) != 0) // 创建一个线程
        {
               printf("fail to pthraed_create");
               exit(-1);
        }

        msg_send.type = MSG_TYPE1; // 另外一个进程改成MSG_TYPE2
        printf("input->\n");
        while (1)
        {
                fgets(msg_send.buf, 100, stdin);
                msgsnd(msgid, &msg_send, MSG_LEN(msg_send), 0);
        }
        msgctl(msgid, IPC_RMID, NULL); // 不用了删除消息队列
        return 0;
}

void *thraed_entery(void *arg)
{
    while (1)
    {
                msgrcv(msgid, &msg_rcv, MSG_LEN(msg_rcv), MSG_TYPE2, 0); // 阻塞接收
                printf("process2:%s\n",  msg_rcv.buf);
    }
}

#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
//成功时返回信号灯的id,失败时返回-1
//key和消息队列关联的key IPC_PRIVATE或ftok
//nsems集合中包含的计数信号灯个数
//semflg标志位IPC CREAT|0666 IPCEXCL

#include <sys/ipc.h>
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ..);
//成功时返回0,失败时返回EOF
//semid 要操作的信号灯集id
//semnum要操作的集合中的信号灯编号,从0开始
//cmd执行的操作SETVAL IPC-RMID，设置值和删除
//union semun 取决于cmd

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(Linux-specific) */
};

union semun myun;
myun.val = 2;
if (semctl(semid, 0, SETVAL, myun) <0) 
{
    perror("semctl");
    exit(-1);
}
myun.val =0;
if (semctl(semid, 1, SETVAL, myun) <0) 
{
	perror("semctl");
    exit(-1);
}       

#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);
//成功时返回0,失败时返回-1
//semid 要操作的信号灯集id
//sops描述对信号灯操作的结构体(数组) 
//5ops要操作的信号灯的个数

struct sembuf
{
    short semnum;
    short sem_op;
    short sem_flg;
};
//semnum 信号灯编号
//sem_op -1: P操作1: V操作，也可以是-2、-3，信号灯的值和它进行运算
//sem_flg о/ IPC_NOWAIT

//主机字节序到网络字节序
u_long htonl (u_long hostlong);  // host to network long
u_short htons (u_short short);  // host to network short

//网络字节序到主机字节序
u_long ntohl (u_long hostlong);
u_short ntohs (u_short short);

in addr_t inet_addr (const char *cp);
//cp:点分形式的IP地址,结果是32位整数(内部包含了字节序的转换,默认是网络字节序的模式)
//特点: 1.仅适应于IPV4
//     2.当出错时,返回-1
//     3.此函数不能用于255. 255. 255.255的转换,全1

#include <arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
//特点: 1.适应于IPV4和IPV6
//     2.能正确的处理255. 255. 255. 255的转换问题
//参数:
//1. af:t协(AF_INET或AF INET6)
//2. src:是一个指针(填写点分形式的IP地址[主要指IPV4])
//3. dst:转换的结果给到dst
//特殊点：
//返回：1代表成功 0：代表错误

#include <pthread.h>
int pthread_mutexinit(pthread_mutext *mutex,
const pthread_mutexattrt * attr);
//成功时返回0,失败时返回错误码
//mutex指向要初始化的互斥锁对象
//attr互斥锁属性, NULL表示缺省属性

tinclude <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
//成功时返回0,失败时返回错误码
//mutex指向要初始化的互斥锁对象
//如果当前锁被其他线程持有，无法获得锁,任务阻塞
//阻塞到锁被释放，系统才会将它唤醒到就绪列表

#include <pthread.h>
int pthread mutexunlock(pthread_mutex_t *mutex);
//成功时返回0,失败时返回错误码
//mutex指向要初始化的互斥锁对象
//执行完临界区要及时释放锁
//持有互斥锁的线程在退出临界区的时候一定要即时释放锁，不然其他等待该互斥锁的线程会被一直阻塞

unsigned int count, value1, value2;
pthread_mutex_t lock;
void *function(void *arg);
int main(void) 
{
    pthread_t a_thread;
    if (pthread_mute_xinit(&lock, NULL) !=0) 
    {
        printf("fail to pthread_mute_xinit\n");
        exit(-1);
    }
    if (pthread_create(&a thread, NULL, function, NULL) != 0)
    {
        printf("fail to pthread_create\n");
        exit(-1);
    }
    while (1)
    {
        count++;
        #ifdef _LOCK_
        pthread_mutex lock(&lock);
        #endif
        value1 = count;
        value2 = count;
        #ifdef _LOCK_
        pthread_mutex_unlock(&lock);
        #endif
    }
    return 0;
}

void *function(void *arg) 
{
    while (1)
    {
        #ifdef LOCK
        pthread_mutex_lock(&lock);
        #endif
        if (value1 != value2) 
        {
            printf("value1 = %u, value2 = %u\n", value1, value2);
            usleep(100000);
        }
        #ifdef _LOCK_
        pthread_mutex_unlock(&lock);
        #endif
    }
    return NULL; 
}

//不使用互斥锁,会出现value1和value2不想等的情况
$ gcc -o test test.c -lpthread
S./test
value1 = 19821, value2 = 19820
value1 = 14553456, value2 = 14553455
value1= 29196032, value2 = 29196031
    
//使用互斥锁，value1和value2会一定相等
$ gcc -o test test.c -lpthread -D_LOCK_  // -D选项：传递一个宏定义_LOCK_
$./test