高级Linux程序设计第五章:进程间通信
来源:互联网 发布:网络门禁系统接线图 编辑:程序博客网 时间:2024/05/17 19:18
详细页面:http://www.verydemo.com/demo_c170_i3158.html
From: http://www.cnblogs.com/forfuture1978/archive/2010/04/29/1723417.html
五种进程间通信的方式:
共享内存(shared memory):其允许多个进程通过读写同一块内存地址来相互通信。
内存映射(Mapped memory):其和共享内存相似,然而它是和文件系统上的一个文件相关联的。
管道(Pipe):其允许一个进程到另一个相关进程的顺序通信。
先入先出队列(FIFO):和管道类似,然而因为其对应于文件系统上的文件名,可以在两个不相关的进程间通信。
Socket:其允许在不同的计算机上的不同进程间通信。
1、共享内存(Shared Memory)
共享内存时进程间通信方式中最快的一种,因为进程是共享同一块内存。
内核并不提供对共享内存访问的同步机制,因而必须自己提供同步方式。
要用共享内存块,需要一个进程首先分配此内存块。
欲访问共享内存块的进程必须要连接到此内存块。
在使用完共享内存块的时候,进程必须要卸载此内存块。
需要有一个进程释放此内存块。
所有的共享内存块都是以4KB的整数倍分配。
1.1、分配
进程用函数shmget分配一个共享内存块。
第一个参数是共享内存块的key
不同的进程可以根据此key来访问同一个共享内存块。
使用IPC_PRIVATE作为key会保证创建一个新的共享内存块。
如果多个进程访问同一个共享内存块,则必须用同一个key。
第二个参数表示内存块的大小。
第三个参数是一系列标志位:
IPC_CREAT创建一个新的内存块。
IPC_EXCL此标志位和IPC_CREAT一起使用。如果key已经存在,则此标志位使得shmget失败。
1.2、连接(Attachment )和卸载(Detachment)
一个进程需要调用shmat来连接一个共享内存。
第一个参数是共享内存块的id,由shmget返回。
第二个参数是一个指针,其指向共享内存块映射的内存地址,如果是NULL,则系统会自动选择一个可用的内存地址。
第三个参数是标志位:
SHM_RND表示第二个参数所指定的地址必须同页的大小对齐。
SHM_RDONLY表示此内存块只读。
此函数返回值是连接的共享内存的起始地址。
共享内存块可用函数shmdt卸载,应传给它共享内存块的起始地址。
调用exit及exec函数自动卸载共享内存块。
1.3、控制和释放共享内存块
shmctl函数可用返回和修改共享内存块的信息。
第一个参数是共享内存块id
欲得到一个共享内存块的信息,第二个参数设为IPC_STAT,第三个参数是指向shmid_ds结构体的指针。
欲删除一个共享内存块,第二个参数设为IPC_RMID,第三个参数设为NULL。
一个共享内存块在使用结束后,必须用shmctl显式的释放。
调用exit和exec自动卸载共享内存块,但是不释放。
#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ()
{
int segment_id;
char* shared_memory;
struct shmid_ds shmbuffer;
int segment_size;
const int shared_segment_size = 0x6400;
/* Allocate a shared memory segment. */
segment_id = shmget (IPC_PRIVATE, shared_segment_size, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
/* Attach the shared memory segment. */
shared_memory = (char*) shmat (segment_id, 0, 0);
printf (“shared memory attached at address %p\n”, shared_memory);
/* Determine the segment’s size. */
shmctl (segment_id, IPC_STAT, &shmbuffer);
segment_size = shmbuffer.shm_segsz;
printf (“segment size: %d\n”, segment_size);
/* Write a string to the shared memory segment. */
sprintf (shared_memory, “Hello, world.”);
/* Detach the shared memory segment. */
shmdt (shared_memory);
/* Reattach the shared memory segment, at a different address. */
shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0);
printf (“shared memory reattached at address %p\n”, shared_memory);
/* Print out the string from shared memory. */
printf (“%s\n”, shared_memory);
/* Detach the shared memory segment. */
shmdt (shared_memory);
/* Deallocate the shared memory segment. */
shmctl (segment_id, IPC_RMID, 0);
return 0;
}
ipcs命令可用查看进程间通信机制的信息
使用-m可查看共享内存的信息
% ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 1627649 user 640 25600 0
ipcrm命令可删除进程间通信对象.
% ipcrm shm 1627649
[liuchao@localhost ~]$ ipcs
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 196608 liuchao 600 393216 2 dest
0x764867bd 65537 liuchao 600 1 0
0x2c0056d5 98306 liuchao 600 1 0
0x500e7827 131075 liuchao 600 1 0
0x20e0f21d 163844 liuchao 600 1 0
0x00000000 229381 liuchao 600 393216 2 dest
0x00000000 262150 liuchao 600 393216 2 dest
0x00000000 294919 liuchao 600 393216 2 dest
0x00000000 327688 liuchao 600 393216 2 dest
0x00000000 360457 liuchao 600 393216 2 dest
0x00000000 393226 liuchao 600 393216 2 dest
0x00000000 425995 liuchao 600 393216 2 dest
0x00000000 458764 liuchao 600 393216 2 dest
0x00000000 491533 liuchao 600 393216 2 dest
0x00000000 557070 liuchao 600 393216 2 dest
0x00000000 589839 liuchao 600 393216 2 dest
------ Semaphore Arrays --------
key semid owner perms nsems
0x59d9bc4a 0 liuchao 600 1
0x3bd464f2 32769 liuchao 600 1
------ Message Queues --------
key msqid owner perms used-bytes messages
2、进程信号量
2.1、分配(Allocation)和释放(Deallocation)
调用semget分配一个信号量,调用semctl来释放一个信号量。
semget的参数为一个信号量集的key,信号量集中的信号量的个数,权限标志位,返回值为信号量集id。
semctl的参数为信号量集的id,信号量集中的信号量的个数,IPC_RMID。
当所有的使用信号量的进程结束后,信号量仍然存在。
最后一个使用信号量集的进程必须显式的删除它。
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/types.h>
/* We must define union semun ourselves. */
union semun {
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};
/* Obtain a binary semaphore’s ID, allocating if necessary. */
int binary_semaphore_allocation (key_t key, int sem_flags)
{
return semget (key, 1, sem_flags);
}
/* Deallocate a binary semaphore. All users must have finished their
use. Returns -1 on failure. */
int binary_semaphore_deallocate (int semid)
{
union semun ignored_argument;
return semctl (semid, 1, IPC_RMID, ignored_argument);
}
2.2、初始化信号量
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
/* We must define union semun ourselves. */
union semun {
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};
/* Initialize a binary semaphore with a value of 1. */
int binary_semaphore_initialize (int semid)
{
union semun argument;
unsigned short values[1];
values[0] = 1;
argument.array = values;
return semctl (semid, 0, SETALL, argument);
}
2.3、Wait和Post操作
semop函数支持wait和post操作。
第一个参数是信号量集id。
第二个参数是一个sembuf结构体的数组。
第三个参数是数组的长度。
sembuf结构体:
sem_num是信号量集中作为操作对象的信号量的号。
sem_op表示对信号量的操作。如果sem_op是正数,则其将被加到信号量的值上。如果sem_op是负数,则得到其绝对值,如果此值能够使得信号量的值为负,则阻塞当前线程,直到此信号量的值等于sem_op的绝对值。如果sem_op为零,阻塞当前线程,直到信号量的值为零。
sem_flg是标志位,IPC_NOWAIT使得此操作不会被阻塞,SEM_UNDO表示当进程结束的时候,系统自动取消此次操作。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
/* Wait on a binary semaphore. Block until the semaphore value is positive, then
decrement it by 1. */
int binary_semaphore_wait (int semid)
{
struct sembuf operations[1];
/* Use the first (and only) semaphore. */
operations[0].sem_num = 0;
/* Decrement by 1. */
operations[0].sem_op = -1;
/* Permit undo’ing. */
operations[0].sem_flg = SEM_UNDO;
return semop (semid, operations, 1);
}
/* Post to a binary semaphore: increment its value by 1.
This returns immediately. */
int binary_semaphore_post (int semid)
{
struct sembuf operations[1];
/* Use the first (and only) semaphore. */
operations[0].sem_num = 0;
/* Increment by 1. */
operations[0].sem_op = 1;
/* Permit undo’ing. */
operations[0].sem_flg = SEM_UNDO;
return semop (semid, operations, 1);
}
3、内存映射(Mapped Memory)
3.1、映射一个普通文件
使用mmap函数可将一个普通文件映射到进程内存中。
第一个参数是文件将映射到的内存地址,NULL使得Linux自动选择一个可用的地址。
第二个参数是映射的长度。
第三个参数是映射的内存的保护模式:PROT_READ,PROT_WRITE,PROT_EXEC。
第四个参数是一个标志位:
MAP_FIXED表示映射的内存地址必须和页对齐。
MAP_PRIVATE表示写入映射的内存的数据不会写入关联的文件,而是写入另一个文件副本,对其他线程不可见。
MAP_SHARED表示写入映射的内存的数据会立即写入关联的文件,不会有缓存。
第五个参数是关联文件的文件描述符。
第六个参数是映射的文件的偏移量。
(mmap-write.c) Write a Random Number to a Memory-Mapped File
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#define FILE_LENGTH 0x100
/* Return a uniformly random number in the range [low,high]. */
int random_range (unsigned const low, unsigned const high)
{
unsigned const range = high - low + 1;
return low + (int) (((double) range) * rand () / (RAND_MAX + 1.0));
}
int main (int argc, char* const argv[])
{
int fd;
void* file_memory;
/* Seed the random number generator. */
srand (time (NULL));
/* Prepare a file large enough to hold an unsigned integer. */
fd = open (argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
lseek (fd, FILE_LENGTH+1, SEEK_SET);
write (fd, “”, 1);
lseek (fd, 0, SEEK_SET);
/* Create the memory mapping. */
file_memory = mmap (0, FILE_LENGTH, PROT_WRITE, MAP_SHARED, fd, 0);
close (fd);
/* Write a random integer to memory-mapped area. */
sprintf((char*) file_memory, “%d\n”, random_range (-100, 100));
/* Release the memory (unnecessary because the program exits). */
munmap (file_memory, FILE_LENGTH);
return 0;
}
(mmap-read.c) Read an Integer from a Memory-Mapped File, and Double It
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#define FILE_LENGTH 0x100
int main (int argc, char* const argv[])
{
int fd;
void* file_memory;
int integer;
/* Open the file. */
fd = open (argv[1], O_RDWR, S_IRUSR | S_IWUSR);
/* Create the memory mapping. */
file_memory = mmap (0, FILE_LENGTH, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
close (fd);
/* Read the integer, print it out, and double it. */
sscanf (file_memory, “%d”, &integer);
printf (“value: %d\n”, integer);
sprintf ((char*) file_memory, “%d\n”, 2 * integer);
/* Release the memory (unnecessary because the program exits). */
munmap (file_memory, FILE_LENGTH);
return 0;
}
3.2、共同访问一个文件
不同的进程可以通过将同一个文件映射到内存来通信。
设置MAP_SHARD使得写入到映射的内存的数据会立即写入关联的文件,并对另一个文件可见。
如果不做以上设定,则Linux会对数据进行缓存,可以用函数msync将缓存写入文件。
前两个参数表示映射的内存块。
第三个参数是标志位:
MS_ASTYNC:写缓存并不立即执行。
MS_SYNC:写缓存立即执行。
MS_INVALIDATE:所有的文件映射都被刷新,可以看到最新的更新。
msync (mem_addr, mem_length, MS_SYNC | MS_INVALIDATE);
设置MAP_PRIVATE将创建一个写即复制的映射区。写入这些映射区的数据仅仅在当前进程可见,对其他进程不可见。
4、管道(Pipes)
4.1、创建管道
int pipe_fds[2];
int read_fd;
int write_fd;
pipe (pipe_fds);
read_fd = pipe_fds[0];
write_fd = pipe_fds[1];
4.2、用管道来进行子进程和父进程之间的通信
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
/* Write COUNT copies of MESSAGE to STREAM, pausing for a second between each. */
void writer (const char* message, int count, FILE* stream)
{
for (; count > 0; --count) {
/* Write the message to the stream, and send it off immediately. */
fprintf (stream, “%s\n”, message);
fflush (stream);
/* Snooze a while. */
sleep (1);
}
}
/* Read random strings from the stream as long as possible. */
void reader (FILE* stream)
{
char buffer[1024];
/* Read until we hit the end of the stream. fgets reads until either a newline or the end-of-file. */
while (!feof (stream) && !ferror (stream) && fgets (buffer, sizeof (buffer), stream) != NULL)
fputs (buffer, stdout);
}
int main ()
{
int fds[2];
pid_t pid;
/* Create a pipe. File descriptors for the two ends of the pipe are placed in fds. */
pipe (fds);
/* Fork a child process. */
pid = fork ();
if (pid == (pid_t) 0) {
FILE* stream;
/* This is the child process. Close our copy of the write end of the file descriptor. */
close (fds[1]);
/* Convert the read file descriptor to a FILE object, and read from it. */
stream = fdopen (fds[0], “r”);
reader (stream);
close (fds[0]);
}
else {
/* This is the parent process. */
FILE* stream;
/* Close our copy of the read end of the file descriptor. */
close (fds[0]);
/* Convert the write file descriptor to a FILE object, and write to it. */
stream = fdopen (fds[1], “w”);
writer (“Hello, world.”, 5, stream);
close (fds[1]);
}
return 0;
}
4.3、用管道重定向标准输入,标准输出,错误流。
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main ()
{
int fds[2];
pid_t pid;
/* Create a pipe. File descriptors for the two ends of the pipe are placed in fds. */
pipe (fds);
/* Fork a child process. */
pid = fork ();
if (pid == (pid_t) 0) {
/* This is the child process. Close our copy of the write end of the file descriptor. */
close (fds[1]);
/* Connect the read end of the pipe to standard input. */
dup2 (fds[0], STDIN_FILENO);
/* Replace the child process with the “sort” program. */
execlp (“sort”, “sort”, 0);
}
else {
/* This is the parent process. */
FILE* stream;
/* Close our copy of the read end of the file descriptor. */
close (fds[0]);
/* Convert the write file descriptor to a FILE object, and write to it. */
stream = fdopen (fds[1], “w”);
fprintf (stream, “This is a test.\n”);
fprintf (stream, “Hello, world.\n”);
fprintf (stream, “My dog has fleas.\n”);
fprintf (stream, “This program is great.\n”);
fprintf (stream, “One fish, two fish.\n”);
fflush (stream);
close (fds[1]);
/* Wait for the child process to finish. */
waitpid (pid, NULL, 0);
}
return 0;
}
4.4、打开(popen)和关闭(pclose)管道
#include <stdio.h>
#include <unistd.h>
int main ()
{
FILE* stream = popen (“sort”, “w”);
fprintf (stream, “This is a test.\n”);
fprintf (stream, “Hello, world.\n”);
fprintf (stream, “My dog has fleas.\n”);
fprintf (stream, “This program is great.\n”);
fprintf (stream, “One fish, two fish.\n”);
return pclose (stream);
}
4.5、先进先出队列(FIFOs)
一个先进先出队列是一个管道,只不过在文件系统中有文件名与之对应。
FIFOs又被称为命名管道。
mkfifo命令可以创建一个FIFO
% mkfifo /tmp/fifo
% ls -l /tmp/fifo
prw-rw-rw- 1 samuel users 0 Jan 16 14:04 /tmp/fifo
mkfifo函数可以创建一个FIFO
第一个参数是文件系统中的路径。
第二个参数是权限。
访问FIFO和访问一个普通文件相同。
如果两个进程通过FIFO进行通信,则需要一个进程打开一个FIFO用于写,另一个进程打开同一个FIFO用于读。
5、套接字(Sockets)
创建一个套接字:
命名空间:PF_LOCAL和PF_UNIX表示本地命名空间,PF_INET表示互联网命名空间。
通信方式:SOCK_STREAM表示面向连接的套接字,SOCK_DGRAM表示面向数据报的套接字。
关闭套接字:close
连接套接字:欲在客户端和服务器段建立连接,客户端调用connect,指向服务器的地址,服务器端等待accept连接。
绑定套接字:bind,将套接字绑定到一个地址。
监听套接字:listen,使得服务器监听一个端口,等待accept一个连接。
接受套接字:accept,接受一个来自客户端的连接。
5.1、本地命名空间套接字
访问同一台机器的套接字可以使用本地命名空间:PF_LOCAL和PF_UNIX
(socket-server.c) Local Namespace Socket Server
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
/* Read text from the socket and print it out. Continue until the
socket closes. Return nonzero if the client sent a “quit”
message, zero otherwise. */
int server (int client_socket)
{
while (1) {
int length;
char* text;
/* First, read the length of the text message from the socket. If read returns zero, the client closed the connection. */
if (read (client_socket, &length, sizeof (length)) == 0)
return 0;
/* Allocate a buffer to hold the text. */
text = (char*) malloc (length);
/* Read the text itself, and print it. */
read (client_socket, text, length);
printf (“%s\n”, text);
/* Free the buffer. */
free (text);
/* If the client sent the message “quit,” we’re all done. */
if (!strcmp (text, “quit”))
return 1;
}
}
int main (int argc, char* const argv[])
{
const char* const socket_name = argv[1];
int socket_fd;
struct sockaddr_un name;
int client_sent_quit_message;
/* Create the socket. */
socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0);
/* Indicate that this is a server. */
name.sun_family = AF_LOCAL;
strcpy (name.sun_path, socket_name);
bind (socket_fd, &name, SUN_LEN (&name));
/* Listen for connections. */
listen (socket_fd, 5);
/* Repeatedly accept connections, spinning off one server() to deal with each client. Continue until a client sends a “quit” message. */
do {
struct sockaddr_un client_name;
socklen_t client_name_len;
int client_socket_fd;
/* Accept a connection. */
client_socket_fd = accept (socket_fd, &client_name, &client_name_len);
/* Handle the connection. */
client_sent_quit_message = server (client_socket_fd);
/* Close our end of the connection. */
close (client_socket_fd);
} while (!client_sent_quit_message);
/* Remove the socket file. */
close (socket_fd);
unlink (socket_name);
return 0;
}
(socket-client.c) Local Namespace Socket Client
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
/* Write TEXT to the socket given by file descriptor SOCKET_FD. */
void write_text (int socket_fd, const char* text)
{
/* Write the number of bytes in the string, including NUL-termination. */
int length = strlen (text) + 1;
write (socket_fd, &length, sizeof (length));
/* Write the string. */
write (socket_fd, text, length);
}
int main (int argc, char* const argv[])
{
const char* const socket_name = argv[1];
const char* const message = argv[2];
int socket_fd;
struct sockaddr_un name;
/* Create the socket. */
socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0);
/* Store the server’s name in the socket address. */
name.sun_family = AF_LOCAL;
strcpy (name.sun_path, socket_name);
/* Connect the socket. */
connect (socket_fd, &name, SUN_LEN (&name));
/* Write the text on the command line to the socket. */
write_text (socket_fd, message);
close (socket_fd);
return 0;
}
5.2、互联网套接字
(socket-inet.c) Read from a WWW Server
#include <stdlib.h>
#include <stdio.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
/* Print the contents of the home page for the server’s socket. Return an indication of success. */
void get_home_page (int socket_fd)
{
char buffer[10000];
ssize_t number_characters_read;
/* Send the HTTP GET command for the home page. */
sprintf (buffer, “GET /\n”);
write (socket_fd, buffer, strlen (buffer));
/* Read from the socket. The call to read may not
return all the data at one time, so keep trying until we run out. */
while (1) {
number_characters_read = read (socket_fd, buffer, 10000);
if (number_characters_read == 0)
return;
/* Write the data to standard output. */
fwrite (buffer, sizeof (char), number_characters_read, stdout);
}
}
int main (int argc, char* const argv[])
{
int socket_fd;
struct sockaddr_in name;
struct hostent* hostinfo;
/* Create the socket. */
socket_fd = socket (PF_INET, SOCK_STREAM, 0);
/* Store the server’s name in the socket address. */
name.sin_family = AF_INET;
/* Convert from strings to numbers. */
hostinfo = gethostbyname (argv[1]);
if (hostinfo == NULL)
return 1;
else
name.sin_addr = *((struct in_addr *) hostinfo->h_addr);
/* Web servers use port 80. */
name.sin_port = htons (80);
/* Connect to the Web server */
if (connect (socket_fd, &name, sizeof (struct sockaddr_in)) == -1) {
perror (“connect”);
return 1;
}
/* Retrieve the server’s home page. */
get_home_page (socket_fd);
return 0;
}
- 高级Linux程序设计第五章:进程间通信
- 高级Linux程序设计第五章:进程间通信
- 高级Linux程序设计第五章:进程间通信
- LINUX 进程间通信程序设计
- 【原创】《Linux高级程序设计》杨宗德著 - 进程管理与程序开发 - System V进程间通信基础
- 高级Linux程序设计第三章:进程
- 《Linux程序设计》--读书笔记---第十三章进程间通信:管道
- 【原创】《Linux高级程序设计》杨宗德著 - 进程管理与程序开发 - System V进程间通信之消息队列
- Linux程序设计笔记-进程间通信
- LINUX 进程间通信程序设计一
- LINUX 进程间通信程序设计-2
- Linux高级进程间通信 共享存储
- Linux高级进程间通信:信号量
- Linux高级进程间通信:消息队列
- Linux高级进程间通信:纪录锁
- linux高级程序_进程间通信
- 高级进程间通信
- Linux程序设计第五章
- java 读取 excel 2003 或 excel 2007
- 关于MySQL变量innodb_rollback_on_timeout一些讨论
- Python 拷贝对象(深拷贝deepcopy与浅拷贝copy)
- 宝宝起名的重要性
- Netbeans 7.3 兼容SVN客户端1.8
- 高级Linux程序设计第五章:进程间通信
- VC++中计算程序的运行时间
- ExtJS 常用工具函数
- Android获取已安装应用信息(图标 名称 版本号 包)
- 利用JavaScript访问数据库
- Linux下JDK安装
- SharedPreferences、editor
- PHP基础之数组(1)
- 51系列小型操作系统精髓 简单实现9 C语言版优化后发布(有图)