消息队列message queue
最近在Hi3515上调试Qt与DVR程序，发现他们之间使用消息队列通信的，闲暇之余，就总结了一下消息队列，呵呵，自认为通俗易懂，同时，在应用中也发现了消息队列的强大之处。
特点：
1.消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识.
2.消息队列允许一个或多个进程向它写入与读取消息.
3.管道和命名管道都是通信数据都是先进先出的原则。
4.消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取.比FIFO更有优势。
目前主要有两种类型的消息队列：
POSIX消息队列以及系统V消息队列，系统V消息队列目前被大量使用。系统V消息队列是随内核持续的，只有在内核重起或者人工删除时，该消息队列才会被删除。
消息队列的操作：
msgget用于创建一个新队列或打开一个现在的队列.
msgsnd用于将新消息添加到队列尾端.
msgrcv用于从队列中接收消息.
msgctl用于对消息队列控制,比如:(删除消息队列).
1.获得key值
key_t ftok(char *pathname, int projid);
#include <sys/types.h>
#include <sys/ipc.h>
参数:
pathname：文件名（含路径）,通常设置为当前目录“.”
projid：项目ID，必须为非0整数（0-255）.
2.创建消息队列
int msgget(key_t key, int msgflag);
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
功能：
用于创建一个新的或打开一个已经存在的消息队列，此消息队列与key相对应。
参数：
key：函数ftok的返回值或IPC_PRIVATE。
msgflag：
IPC_CREAT:创建新的消息队列。
IPC_EXCL:与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
IPC_NOWAIT:读写消息队列要求无法满足时，不阻塞。
返回值：
调用成功返回队列标识符,否则返回-1.
在以下两种情况下，将创建一个新的消息队列：
1、如果没有与键值key相对应的消息队列，并且msgflag中包含了IPC_CREAT标志位。
2、key参数为IPC_PRIVATE。
例：
int open_queue(key_t keyval)
{
int qid;
if((qid=msgget(keyval, IPC_CREAT)) == -1)
{
return -1;
}
return qid;
}
3.消息队列属性控制
int msgctl(int msqid, int cmd, struct msqid_ds *buf)
功能:
对消息队列进行各种控制操作,操作的动作由cmd控制。
参数:
msqid:消息队列ID，消息队列标识符，该值为msgget创建消息队列的返回值。
cmd:
IPC_STAT:将msqid相关的数据结构中各个元素的当前值存入到由buf指向的结构中.
IPC_SET:将msqid相关的数据结构中的元素设置为由buf指向的结构中的对应值.
IPC_RMID:删除由msqid指示的消息队列,将它从系统中删除并破坏相关数据结构.
buf:消息队列缓冲区
struct msqid_ds {
struct ipc_perm msg_perm; /* Ownership and permissions*/
time_t msg_stime; /* Time of last msgsnd() */
time_t msg_rtime; /* Time of last msgrcv() */
time_t msg_ctime; /* Time of last change */
unsigned long __msg_cbytes; /* Current number of bytes in queue (non-standard) */
msgqnum_t msg_qnum; /* Current number of messages in queue */
msglen_t msg_qbytes; /* Maximum number of bytesallowed in queue */
pid_t msg_lspid; /* PID of last msgsnd() */
pid_t msg_lrpid; /* PID of last msgrcv() */
};
struct ipc_perm {
key_t key; /* Key supplied to msgget() */
uid_t uid; /* Effective UID of owner */
gid_t gid; /* Effective GID of owner */
uid_t cuid; /* Effective UID of creator */
gid_t cgid; /* Effective GID of creator */
unsigned short mode; /* Permissions */
unsigned short seq; /* Sequence number */
};
例1：//获取消息队列的值
int get_queue_ds(int qid, struct msgdid_ds *buf)
{
if(msgctl(qid, IPC_STAT, buf) == -1)
{
return -1;
}
return 0;
}
例2：//修改消息队列的值
int change_queue_mode(int qid, char *mode)
{
struct msqid_ds tmpbuf;
/*Retrieve a current copy of the internal data structure*/
get_queue_ds(qid, &tmpbuf);
/*Change the permissions using an old trick*/
sscanf(mode, "%ho", &tmpbuf.msg_perm.mode);
/*Update the internal data structure*/
if(msgctl(qid, IPC_SET, &tmpbuf) == -1)
{
return -1;
}
return 0;
}
例3：//删除消息队列
int remove_queue(int qid)
{
if(msgctl(qid, IPC_RMID, 0) == -1)
{
return -1;
}
return 0;
}
4．发送信息到消息队列
int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflag);
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
功能:将新消息添加到队列尾端,即向消息队列中发送一条消息。
参数：
msqid:已打开的消息队列id
msgp:存放消息的结构体指针。
msgflag:函数的控制属性。
消息结构msgbuf为:
struct msgbuf
{
long mtype;//消息类型
char mtext[1];//消息正文，消息数据的首地址
}
msgsz:消息数据的长度。
msgflag:
IPC_NOWAIT: 指明在消息队列没有足够空间容纳要发送的消息时，msgsnd立即返回。
0:msgsnd调用阻塞直到条件满足为止.（一般选这个）
5.从消息队列接收信息
ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz, long msgtype, int msgflag)
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
功能:从队列中接收消息
参数:
msqid:已打开的消息队列id
msgp:存放消息的结构体指针。
msgsz:消息的字节数，指定mtext的大小。
msgtype:消息类型，消息类型 mtype的值。
msgflag:函数的控制属性。
msgflag:
MSG_NOERROR:若返回的消息比nbytes字节多,则消息就会截短到nbytes字节,且不通知消息发送进程.
IPC_NOWAIT:调用进程会立即返回.若没有收到消息则返回-1.
0:msgrcv调用阻塞直到条件满足为止.
在成功地读取了一条消息以后，队列中的这条消息将被删除。
四个列子：
例1：//接收消息
int read_message(int qid, long type, struct mymsgbuf *qbuf)
{
int result, length;
length = sizeof(struct mymsgbuf)-sizeof(long);
if((result = msgrcv(qid, qbuf, length, type, 0)) == -1)
{
return -1;
}
return result;
}
例2：//消息队列之简单收发测试
#include <sys/types.h>
#include <sys/msg.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
struct msg_buf
{
int mtype;//消息类型
char data[255];//数据
};
int main(int argc, char *argv[])
{
key_t key;
int msgid;
int ret;
struct msg_buf msgbuf;
//获取key值
key = ftok(".", 'a');
printf("key = [%x]\n", key);
//创建消息队列
msgid = msgget(key, IPC_CREAT|0666);/*通过文件对应*/
if(msgid == -1)
{
printf("creat error\n");
return -1;
}
//以当前进程类型，非阻塞方式发送"test data"到消息队列
msgbuf.mtype = getpid();
strcpy(msgbuf.data, "test data");
ret = msgsnd(msgid, &msgbuf, sizeof(msgbuf.data), IPC_NOWAIT);
if(ret == -1)
{
printf("send message err\n");
return -1;
}
//以非阻塞方式接收数据
memset(&msgbuf, 0, sizeof(msgbuf));
ret = msgrcv(msgid, &msgbuf, sizeof(msgbuf.data), getpid(), IPC_NOWAIT);
if(ret == -1)
{
printf("receive message err\n");
return -1;
}
printf("receive msg = [%s]\n", msgbuf.data);
return 0;
}
例3：//一个最简单的创建消息队列，并在同一个消息队列中通信
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h> //要加这个头文件
struct msgbuf{
long mtype;
char mtext[100];
}; //存放消息类型和消息内容的结构体
int main()
{
key_t key;
int msgid;
struct msgbuf msg1,msg2; //msg1用来发送，msg2用来接收
key=ftok(".", 0xf0); //获得消息队列标识符
if( (msgid = msgget(key, IPC_CREAT|0666)) < 0 ) //创建一个消息队列
{
perror("msgget error");
exit(1);
}
msg1.mtype = 1; //消息类型为1，这个可以区别多个消息
memset(msg1.mtext, 0, 100); //将数组清0
strcpy(msg1.mtext, "hello"); //用strcpy给消息内容赋值
msgsnd(msgid, &msg1, strlen(msg1.mtext)+1, 0); //发送时最后加上一个‘\0’
printf("send %s\n", msg1.mtext);
msgrcv(msgid, &msg2, 100, 1, 0); //接收1发过来的消息，存到msg2中
printf("receive %s\n", msg2.mtext);
msgctl(msgid, IPC_RMID,NULL); //删除消息队列
return 0;
}
例4：//进程间消息队列通信
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <string.h>
#include <signal.h>
struct msgbuf{
int mtype;
char mtext[100];
};
int main()
{
key_t key;
pid_t pid;
int msgid;
struct msgbuf msg;
key=ftok(".", 0x01);
if ( (msgid = msgget(key, IPC_CREAT|0666)) <0 )
{
perror("msgget error");
exit(1);
}
//创建一个进程
if ( (pid = fork()) < 0 )
{
perror("fork error");
exit(1);
}
//子进程收信息
else if (pid==0)
{
while(1)
{
memset(msg.mtext,0,100);
msgrcv(msgid,&msg,100,2,0); //receive the msg from 2
printf("\rbbb:%s\naaa:",msg.mtext);
fflush(stdout);
}
exit(0);
}
//父进程发信息
else
{
while(1)
{
memset(msg.mtext,0,100);
printf("aaa:");
fgets(msg.mtext,100,stdin);
if (strncmp("bye",msg.mtext,3)==0)//如果前3个字符为bye,则退出
{
kill(pid,SIGSTOP);
exit(1);
}
msg.mtype=1;//send to 1
msg.mtext[strlen(msg.mtext)-1]='\0';
msgsnd(msgid,&msg,strlen(msg.mtext)+1,0);
}
}
return 0;
}
乱码了怎么办？经常出现乱码的情况、今天把以前的资料翻出来了，乱码的问题已经不是问题！
总结；
1.要看服务器端php页面的编码，一般情况下我们保存utf-8,
服务器要和浏览器编码一致，，服务器是utf-8的，浏览器也要使用utf-8来打开
2.php给浏览器发送文件时，也就是通过header函数发送，
header("Content-Type:text/html; charset=utf-8");
告诉浏览器你要使用什么编码来打开我给你发的文件
3.静态页面，浏览器端
<meta http-equiv="Conytent-Type" Content="text/html; charset=utf-8">
4.编写代码的文件：通过另存为--->选择编码--->utf-8
5.数据库，保存数据时（数据存储在服务器端）设置编码格式。通过default charset=utf8;
通过黑窗口访问的时候，mysql_query('set names utf8');
驱动程序：
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/syscalls.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/of_platform.h>
#include <linux/uaccess.h>
#include <linux/string.h>
#include <mach/gpio.h>
#include <mach/irqs.h>
#define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
struct fpga_key_dev
{
struct cdev cdev;
dev_t devno;
char test[20];
struct class *fpga_key_class;
struct fasync_struct *async_queue;
int message_cdev_open;
};
struct fpga_key_dev fpga_key_dev;
irqreturn_t irq_handler(int irqno, void *dev_id)
{
struct fpga_key_dev *dev = &fpga_key_dev;
static int count = 0;
printk("fpga key down = %d\n", count);
if (dev->async_queue)
kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
return IRQ_HANDLED;
}
static int fpga_key_open(struct inode *node, struct file *fd)
{
struct fpga_key_dev *dev;
printk("fpga_key_open()++\n");
printk("node->i_cdev = %x\n", (unsigned int)node->i_cdev);
dev = container_of(node->i_cdev, struct fpga_key_dev, cdev);
printk("dev->cdev = %x\n", (unsigned int)&dev->cdev);
printk("dev = %x\n", (unsigned int)dev);
if (!dev->message_cdev_open) {
dev->message_cdev_open = 1;
fd->private_data = dev;
}
else{
return -EFAULT;
}
printk("test[20] = %s\n",dev->test);
printk("fpga_key_open()--\n");
return 0;
}
static ssize_t fpga_key_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
{
char temp_buffer [20];
int print_size = 0;
printk("fpga_key_wirte()++\n");
if(len > 20)
print_size = 20;
else
print_size = len;
printk("print_size = %d; len = %d\n", print_size, len);
if(copy_from_user(temp_buffer, buf, print_size))
return -EFAULT;
printk("writing data:%s", temp_buffer);
printk("fpga_key_wirte()--\n");
return print_size;
}
static ssize_t fpga_key_read(struct file *fd, char __user *buf, size_t len, loff_t *ptr)
{
char *temp_buffer = "Hello fpga_key_read !\n";
int print_size = 0;
printk("fpga_key_read()++\n");
if(len > strnlen(temp_buffer,20))
print_size = strnlen(temp_buffer,20);
else
print_size = len;
printk("print_size = %d; len = %d\n", print_size, len);
if(copy_to_user(buf, temp_buffer, print_size))
return -EFAULT;
printk("%s", temp_buffer);
printk("fpga_key_read()--\n");
return print_size;
}
static int fpga_key_fasync(int fd, struct file *filp, int mode)
{
struct fpga_key_dev *dev = filp->private_data;
printk("fpga_key_fasync()++\n");
fasync_helper(fd, filp, mode, &dev->async_queue);
printk("fpga_key_fasync()--\n");
return 0;
}
static int fpga_key_release(struct inode *node, struct file *fd)
{
struct fpga_key_dev *dev = fd->private_data;
printk("fpga_key_release()++\n");
dev->message_cdev_open = 0;
fpga_key_fasync(-1, fd, 0);
printk("fpga_key_release()--\n");
return 0;
}
struct file_operations meassage_operatons =
{
.owner = THIS_MODULE,
.open = fpga_key_open,
.write = fpga_key_write,
.read = fpga_key_read,
.fasync = fpga_key_fasync,
.release = fpga_key_release,
};
static int __init fpga_key_init(void)
{
struct fpga_key_dev * dev;
char * temp_char = "hello world\n";
int ret = 0;
int irq = 0;
printk("fpga_key_to_app_init(void)++\n");
dev = &fpga_key_dev;
strcpy(dev->test, temp_char);;
alloc_chrdev_region(&dev->devno, 0, 1, "fpga_key_to_app");
cdev_init(&dev->cdev, &meassage_operatons);
cdev_add(&dev->cdev, dev->devno, 1);
dev->fpga_key_class = class_create(THIS_MODULE, "fpga_key_class");
if(IS_ERR(dev->fpga_key_class)) {
printk("Err: failed in creating class./n");
goto fail1;
}
device_create(dev->fpga_key_class, NULL, dev->devno, NULL, "fpga_key");
//init irq
ret = gpio_request(GPIO_TO_PIN(1, 27), "fpga_key_inter");
if(ret){
printk("gpio_request() failed !\n");
goto fail1;
}
ret = gpio_direction_input(GPIO_TO_PIN(1, 27));
if(ret){
printk("gpio_direction_input() failed !\n");
goto fail2;
}
irq = gpio_to_irq(GPIO_TO_PIN(1, 27));
if(irq < 0){
printk("gpio_to_irq() failed !\n");
ret = irq;
goto fail2;
}
printk("irq = %d\n", irq);
ret = request_irq(irq,
irq_handler,
IRQF_TRIGGER_FALLING | IRQF_SHARED,
"fpga_key_inter",
&dev->devno);
if(ret){
printk("request_irq() failed ! %d\n", ret);
goto fail2;
}
printk("fpga_key_to_app_init(void)--\n");
return 0;
fail2:
gpio_free(GPIO_TO_PIN(1, 27));
fail1:
device_destroy(dev->fpga_key_class, dev->devno);
class_destroy(dev->fpga_key_class);
cdev_del(&dev->cdev);
unregister_chrdev_region(dev->devno, 1);
return ret;
}
static void __exit fpga_key_exit(void)
{
struct fpga_key_dev *dev = &fpga_key_dev;
int irq = 0;
printk("fpga_key_to_app_exit(void)++\n");
irq = gpio_to_irq(GPIO_TO_PIN(1, 27));
printk("irq = %d\n", irq);
free_irq(irq, &dev->devno);
gpio_free(GPIO_TO_PIN(1, 27));
device_destroy(dev->fpga_key_class, dev->devno);
class_destroy(dev->fpga_key_class);
cdev_del(&dev->cdev);
unregister_chrdev_region(dev->devno, 1);
printk("fpga_key_to_app_exit(void)--\n");
}
module_init(fpga_key_init);
module_exit(fpga_key_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Driver Monkey");
MODULE_DESCRIPTION("Test fpga_key to App");
测试程序：
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/select.h>
#include<unistd.h>
#include<signal.h>
#include<string.h>
unsigned int flag = 0;
void sig_handler(int sig)
{
printf("%s\n",__FUNCTION__);
flag++;
printf("flag = %d\n", flag);
}
int main(void)
{
char r_buf[20];
char *w_buf = "hello write!\n";
int r_count = 0;
int fd;
int f_flags;
flag++;
fd=open("/dev/fpga_key",O_RDWR);
if(fd<0)
{
perror("open");
return-1;
}
signal(SIGIO, sig_handler);
fcntl(fd, F_SETOWN, getpid());
f_flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, FASYNC | f_flags);
while(1)
{
printf("waiting \n");
sleep(2);
if(flag > 3)
break;
}
close(fd);
return 0;
}