`
mylxiaoyi
  • 浏览: 328425 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

进程间通信(七)

阅读更多

CD数据库程序

现在我们已经了解了我们可以如何使用有名管道来实现一个简单的客户端/服务器系统,我们可以重新查看我们的CD数据库程序并且进行相应的修改。我们同时组合了一些信号处理从而允许我们在进程被中断时进行一些清理动作。我们会使用我们前面的具有一个命令行接口的dbm版本,从而进可能直接的查看代码。

在我们更为详细的讨论新版本的代码之前,让我们先编译这个程序。如果我们有由Web站点所获得的源代码,就可以使用makefile来编译生成server与client程序。

输入server -i使得程序初始化一个新的CD数据库。

无需多言,客户端直到服务器启动并运行时才运行。下面是makefile文件,显示程序是如何组合在一起的。

all: server client
CC=cc
CFLAGS= -pedantic -Wall
# For debugging un-comment the next line
# DFLAGS=-DDEBUG_TRACE=1 -g
# Where, and which version, of dbm are we using.
# This assumes gdbm is pre-installed in a standard place, but we are
# going to use the gdbm compatibility routines, that make it emulate ndbm.
# We do this because ndbm is the ‘most standard’ of the dbm versions.
# Depending on your distribution, these may need changing.
DBM_INC_PATH=/usr/include/gdbm
DBM_LIB_PATH=/usr/lib
DBM_LIB_FILE=gdbm
.c.o:
$(CC) $(CFLAGS) -I$(DBM_INC_PATH) $(DFLAGS) -c $<
app_ui.o: app_ui.c cd_data.h
cd_dbm.o: cd_dbm.c cd_data.h
client_f.o: clientif.c cd_data.h cliserv.h
pipe_imp.o: pipe_imp.c cd_data.h cliserv.h
server.o: server.c cd_data.h cliserv.h
client: app_ui.o clientif.o pipe_imp.o
$(CC) -o client $(DFLAGS) app_ui.o clientif.o pipe_imp.o
server: server.o cd_dbm.o pipe_imp.o
$(CC) -o server -L$(DBM_LIB_PATH) $(DFLAGS) server.o cd_dbm.o pipe_imp.o -
l$(DBM_LIB_FILE)
clean:
rm -f server client_app *.o *~

目标

我们的目标是将程序中处理数据库的部分与与处理用户界面的部分分离开来。我们同时希望运行一个服务器进程,但是允许多个并发客户端。我们同时希望在已有的代码上进行最小的修改。如果可能,我们保持已有的代码不变。

为了使得事情简单,我们同时希望可以在程序内部创建与删除管道,所以不需要系统管理员在我们可以使用这些程序之前创建有名管道。

另外保证我们绝不会在一件事情上"忙等待"浪费CPU时间也是很重要的。正如我们所看到的,Linux允许我们阻塞,等待事件而不是使用重要的资源。我们应使用管道的阻塞特性来保证我们可以更为有效的使用CPU。总之,在理论上,服务器应可以为一个请求的到达等待几个小时。

实现

在前面第7章中单进程版本的程序中,我们使用了一个数据访问函数集合用于数据操作。他们是:

int database_initialize(const int new_database);
void database_close(void);
cdc_entry get_cdc_entry(const char *cd_catalog_ptr);
cdt_entry get_cdt_entry(const char *cd_catalog_ptr, const int track_no);
int add_cdc_entry(const cdc_entry entry_to_add);
int add_cdt_entry(const cdt_entry entry_to_add);
int del_cdc_entry(const char *cd_catalog_ptr);
int del_cdt_entry(const char *cd_catalog_ptr, const int track_no);
cdc_entry search_cdc_entry(const char *cd_catalog_ptr,
int *first_call_ptr);

这些函数为了在客户端与服务器之间进行区分提供了一个合适的场所。

在单进程的实现中,我们可以将这个程序看作具有两部分,尽管他们被编译在一起作为一个程序,如图13-6所示。

在客户端-服务器的实现中,我们希望在程序的两个主要部分之间插入一些合理的有名管道并且提供代码。图13-7显示我们所需要的结构。

在我们的实现中,我们选择将客户端与服务器接口例程放在同一个文件中,pipe_imp.c。这会将所有依赖于用于客户端/服务器实现所用的有名管道的代码放在一个文件中。要传递的数据的格式化与打包与实现有名管道的例程相分离。程序中的调用结构如图13-8所示。

文件app_ui.c,client_if.c与pipe_imp.c被编译与链接到一起提供一个客户端程序。文件cd_dbm.c,server.c与pipe_imp.c被编译与链接到一起提供服务器程序。头文件,cliserv.h,作为将两者连接到一起通用定义头文件。

文件app_ui.c与cd_dbm.c只有一些小的修改,原则上允许分为两个程序。因为程序现在非常大并且代码的主要部分与前一个版本相比并没有大的变化,我们在这里只是讨论文件cliserv.h,client_if.c与pipe_imp.c。

首先我们来看一下cliserv.h。这个文件定义了客户端/服务器接口。这是客户端与服务器实现所需要的。

试验--头文件cliserv.h

1 下面是所需要的#include头文件声明:

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>

2 然后我们定义有名管道。我们使用一个管道用于服务器,另一个管道用于所有的客户端。因为也许会有多个客户端,客户端在其名字中组合一个进程ID来保证他的管道是唯一的:

#define SERVER_PIPE “/tmp/server_pipe”
#define CLIENT_PIPE “/tmp/client_%d_pipe”
#define ERR_TEXT_LEN 80

3 我们将命令实现为枚举类型,而不是#define定义。

这是一个好办法,允许编译器进行更多的类型检测工作,同时有助于程序的调试,因为许多调试器可以显示枚举常量的名字,但是不能显示由#define指令所定义的名字。

第一个typdef指定了将要发送给服务器的请求类型;第二个指定了服务器向客户端的响应类型。

typedef enum {
s_create_new_database = 0,
s_get_cdc_entry,
s_get_cdt_entry,
s_add_cdc_entry,
s_add_cdt_entry,
s_del_cdc_entry,
s_del_cdt_entry,
s_find_cdc_entry
} client_request_e;
typedef enum {
r_success = 0,
r_failure,
r_find_no_more
} server_response_e;

4 接下来我们声明了一个构成可以在两个进程之间双向传递的消息的结构。

typedef struct {
pid_t client_pid;
client_request_e request;
server_response_e response;
cdc_entry cdc_entry_data;
cdt_entry cdt_entry_data;
char error_text[ERR_TEXT_LEN + 1];
} message_db_t;

5 最后,我们来了解执行数据传输的管道接口函数,实现在pipe_imp.c中。这些函数分为服务器端与客户端函数,分别在第一个与第二个块中:

int server_starting(void);
void server_ending(void);
int read_request_from_client(message_db_t *rec_ptr);
int start_resp_to_client(const message_db_t mess_to_send);
int send_resp_to_client(const message_db_t mess_to_send);
void end_resp_to_client(void);
int client_starting(void);
void client_ending(void);
int send_mess_to_server(message_db_t mess_to_send);
int start_resp_from_server(void);
int read_resp_from_server(message_db_t *rec_ptr);
void end_resp_from_server(void);

我们将讨论的其余部分分为客户端接口函数与定义在pipe_imp.c中的服务器端与客户端函数的详细讨论,而且我们会讨论必须的源代码。

客户端接口函数

现在我们来探讨client_if.c。他为数据库访问例程提供了一个虚拟版本,他将请求编码进入message_db_t结构中,然后使用pipe_imp.c中的例程将这些请求传递给服务器。这会使得我们在原始的app_ui.c上进行最小的修改。

试验--客户解释器

1 这个文件实现了在cd_data.h中定义的9个数据库函数。他通过向服务器传递请求并且由函数中返回服务器响应来实现操作,类似于一个中间人。这个文件由#include与常量定义开始:

#define _POSIX_SOURCE
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "cd_data.h"
#include "cliserv.h"

2 静态变量mypid减少了所需要的getpid函数的调用次数。我们使用一个局部函数,read_one_response,来减少重复的代码:

static pid_t mypid;
static int read_one_response(message_db_t *rec_ptr);

3 database_initialize与close例程仍然被调用,但是现在分别用来初始化管道接口的客户端和当客户端退出时移除多余的有名管道。

int database_initialize(const int new_database)
{
if (!client_starting()) return(0);
mypid = getpid();
return(1);
} /* database_initialize */
void database_close(void) {
client_ending();
}

4 get_cdc_entry例被调用用来在指定一个CD类别标题的情况下由数据中获取一个类别实体。在这里我们将请求编码进message_db_t结构中,并且将其传递给服务器。然后我们读取返回的响应放入另一个不同的message_db_t结构中。如果找到一个实体,他就会被作为一个cdc_entry结构被包含进入message_db_t结构中,所以我们需要介绍结构的相关部分:

cdc_entry get_cdc_entry(const char *cd_catalog_ptr)
{
cdc_entry ret_val;
message_db_t mess_send;
message_db_t mess_ret;
ret_val.catalog[0] = ‘\0’;
mess_send.client_pid = mypid;
mess_send.request = s_get_cdc_entry;
strcpy(mess_send.cdc_entry_data.catalog, cd_catalog_ptr);
if (send_mess_to_server(mess_send)) {
if (read_one_response(&mess_ret)) {
if (mess_ret.response == r_success) {
ret_val = mess_ret.cdc_entry_data;
} else {
fprintf(stderr, “%s”, mess_ret.error_text);
}
} else {
fprintf(stderr, “Server failed to respond\n”);
}
} else {
fprintf(stderr, “Server not accepting requests\n”);
}
return(ret_val);
}

5 下面是我们用来避免重复代码的read_one_response函数源码:

static int read_one_response(message_db_t *rec_ptr) {
int return_code = 0;
if (!rec_ptr) return(0);
if (start_resp_from_server()) {
if (read_resp_from_server(rec_ptr)) {
return_code = 1;
}
end_resp_from_server();
}
return(return_code);
}

6 其他的get_xxx,del_xxx与add_xxx例程的实现方式与get_cdc_entry函数类似,为了完整,我们在这里进行介绍。首先是用来读取CD音轨的函数源码:

cdt_entry get_cdt_entry(const char *cd_catalog_ptr, const int track_no)
{
cdt_entry ret_val;
message_db_t mess_send;
message_db_t mess_ret;
ret_val.catalog[0] = ‘\0’;
mess_send.client_pid = mypid;
mess_send.request = s_get_cdt_entry;
strcpy(mess_send.cdt_entry_data.catalog, cd_catalog_ptr);
mess_send.cdt_entry_data.track_no = track_no;
if (send_mess_to_server(mess_send)) {
if (read_one_response(&mess_ret)) {
if (mess_ret.response == r_success) {
ret_val = mess_ret.cdt_entry_data;
} else {
fprintf(stderr, “%s”, mess_ret.error_text);
}
} else {
fprintf(stderr, “Server failed to respond\n”);
}
} else {
fprintf(stderr, “Server not accepting requests\n”);
}
return(ret_val);
}

7 下面是两个是用来添加数据的函数,第一个向类别中添加,而第二个向音轨数据中添加:

int add_cdc_entry(const cdc_entry entry_to_add)
{
message_db_t mess_send;
message_db_t mess_ret;
mess_send.client_pid = mypid;
mess_send.request = s_add_cdc_entry;
mess_send.cdc_entry_data = entry_to_add;
if (send_mess_to_server(mess_send)) {
if (read_one_response(&mess_ret)) {
if (mess_ret.response == r_success) {
return(1);
} else {
fprintf(stderr, “%s”, mess_ret.error_text);
}
} else {
fprintf(stderr, “Server failed to respond\n”);
}
} else {
fprintf(stderr, “Server not accepting requests\n”);
}
return(0);
}
int add_cdt_entry(const cdt_entry entry_to_add)
{
message_db_t mess_send;
message_db_t mess_ret;
mess_send.client_pid = mypid;
mess_send.request = s_add_cdt_entry;
mess_send.cdt_entry_data = entry_to_add;
if (send_mess_to_server(mess_send)) {
if (read_one_response(&mess_ret)) {
if (mess_ret.response == r_success) {
return(1);
} else {
fprintf(stderr, “%s”, mess_ret.error_text);
}
} else {
fprintf(stderr, “Server failed to respond\n”);
}
} else {
fprintf(stderr, “Server not accepting requests\n”);
}
return(0);
}

8 最后是两个用来数据删除的函数:

int del_cdc_entry(const char *cd_catalog_ptr)
{
message_db_t mess_send;
message_db_t mess_ret;
mess_send.client_pid = mypid;
mess_send.request = s_del_cdc_entry;
strcpy(mess_send.cdc_entry_data.catalog, cd_catalog_ptr);
if (send_mess_to_server(mess_send)) {
if (read_one_response(&mess_ret)) {
if (mess_ret.response == r_success) {
return(1);
} else {
fprintf(stderr, “%s”, mess_ret.error_text);
}
} else {
fprintf(stderr, “Server failed to respond\n”);
}
} else {
fprintf(stderr, “Server not accepting requests\n”);
}
return(0);
}
int del_cdt_entry(const char *cd_catalog_ptr, const int track_no)
{
message_db_t mess_send;
message_db_t mess_ret;
mess_send.client_pid = mypid;
mess_send.request = s_del_cdt_entry;
strcpy(mess_send.cdt_entry_data.catalog, cd_catalog_ptr);
mess_send.cdt_entry_data.track_no = track_no;
if (send_mess_to_server(mess_send)) {
if (read_one_response(&mess_ret)) {
if (mess_ret.response == r_success) {
return(1);
} else {
fprintf(stderr, “%s”, mess_ret.error_text);
}
} else {
fprintf(stderr, “Server failed to respond\n”);
}
} else {
fprintf(stderr, “Server not accepting requests\n”);
}
return(0);
}

分享到:
评论

相关推荐

    进程间通信

    七种进程间通信方式: 一.无名管道( pipe ) 二.有名管道( fifo ) 三.共享内存 ( shared memory ) 四.信号 ( sinal ) 五.消息队列 ( message queue ) 六.信号量 ( semophore ) 七.套接字 ( socket ) 进程间通信...

    进程间通信之信号 sinal ) 完整代码

    七种进程间通信方式: 一 无名管道( pipe ) 二 有名管道( fifo ) 三 共享内存 shared memory 四 信号 sinal 五 消息队列 message queue ) 六 信号量 semophore 七 套接字 socket 以上七种进程间通信的完整...

    进程间通信之套接字( socket )——完整代码

    七种进程间通信方式: 一.无名管道( pipe ) 二.有名管道( fifo ) 三.共享内存 ( shared memory ) 四.信号 ( sinal ) 五.消息队列 ( message queue ) 六.信号量 ( semophore ) 七.套接字 ( socket ) 以上七种...

    进程间通信之消息队列 ( message queue )——完整代码

    七种进程间通信方式: 一.无名管道( pipe ) 二.有名管道( fifo ) 三.共享内存 ( shared memory ) 四.信号 ( sinal ) 五.消息队列 ( message queue ) 六.信号量 ( semophore ) 七.套接字 ( socket ) 以上七种...

    linux进程间通信详解

    在Linux操作系统中,进程间通信(IPC,Inter-Process Communication)是多个进程之间共享数据、交换信息的关键技术。本文将深入探讨Linux进程间通信的多种方法、原理以及实际应用。 一、管道(Pipe) 管道是一种...

    Windows进程间通信

    在Windows操作系统中,进程间通信(IPC,Interprocess Communication)是一种技术,允许不同的进程之间共享数据、协调工作或交换信息。这种技术对于多线程和多进程应用的开发至关重要,尤其是在分布式系统和并发编程...

    Linux进程间通信.pdf

    ### Linux进程间通信详解 #### 一、管道通信机制 管道是Linux系统中最早实现的进程间通信(IPC)机制之一。它允许数据在进程之间单向传递,主要用于具有亲缘关系的进程间通信,例如父子进程或兄弟进程。管道分为...

    实验七 进程间通信(二)1

    本文将对进程间通信(IPC)中的共享内存、消息队列、信号量进行详细介绍,并对实验七进程间通信(二)进行解读。 一、 进程间通信(IPC) 进程间通信(IPC)是指不同进程之间的信息交换和共享。 IPC 对象包括共享...

    进程间通信之无名管道(pipe) 完整代码

    七种进程间通信方式: 一 无名管道( pipe ) 二 有名管道( fifo ) 三 共享内存 shared memory 四 信号 sinal 五 消息队列 message queue ) 六 信号量 semophore 七 套接字 socket 以上七种进程间通信的完整...

    Windows 下的进程间通信

    在Windows操作系统中,进程间通信(Inter-Process Communication, IPC)是一种允许不同进程之间交换数据和协调工作的技术。它是多任务环境下程序设计的关键部分,使得应用程序可以共享资源、协同工作,甚至实现...

    进程间通信之有名管道(fifo) 完整代码

    七种进程间通信方式: 一 无名管道( pipe ) 二 有名管道( fifo ) 三 共享内存 shared memory 四 信号 sinal 五 消息队列 message queue ) 六 信号量 semophore 七 套接字 socket 以上七种进程间通信的完整...

    进程间通信之共享内存 shared memory 完整代码

    七种进程间通信方式: 一 无名管道( pipe ) 二 有名管道( fifo ) 三 共享内存 shared memory 四 信号 sinal 五 消息队列 message queue ) 六 信号量 semophore 七 套接字 socket 以上七种进程间通信的完整...

    Linux进程间通信-详解 (经典)

    ### Linux进程间通信详解 #### 一、管道 **1.1 管道概述及相关API应用** 管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用。通常由父进程创建管道,并通过管道与子进程进行...

    进程间通信的比较.doc

    ### 进程间通信知识点详解 #### 一、引言 在现代计算机系统中,进程作为操作系统调度的基本单位,承担着执行程序的功能。由于每个进程都有独立的地址空间,因此不同进程之间需要一种机制来进行数据交换,即所谓的...

    第七章进程间通信1

    【进程间通信】是操作系统中进程协作完成任务的关键机制。在Linux系统中,进程通过多种方式交换信息,如管道、System V的IPC机制(包括信号量、消息队列和共享内存)以及信号。本章主要关注管道通信和System V IPC,...

    嵌入式linux进程间通信

    在嵌入式Linux系统中,进程间通信(IPC,Inter-Process Communication)是实现不同进程协同工作、共享数据的关键技术。UCLinux是一种专为嵌入式设备设计的轻量级Linux内核,它同样支持多种进程间通信机制。本文将...

    UNIX网络编程 第2卷 进程间通信

    unix编程经典系列第二部,进程间通讯,消息队列、共享内存、信号量详细解说

    linux讲解通过共享内存实现进程间的通信

    ### Linux共享内存实现进程间通信详解 #### 一、引言 在Linux系统中,进程间的通信(Inter-Process Communication, IPC)是一项重要的技术,它允许不同进程之间交换数据和同步执行。其中一种高效的进程间通信方法是...

    嵌入式Linux应用程序开发详解第8章进程间通信_linux_

    在嵌入式Linux系统中,进程间通信(IPC,Inter-Process Communication)是多个独立运行的进程之间交换数据的关键机制。这一章节详细探讨了在Linux环境下如何实现有效的进程间通信,这对于开发高效、稳定的嵌入式应用...

Global site tag (gtag.js) - Google Analytics