linux上的进程通信学习笔记

最新推荐文章于 2023-03-26 19:49:26 发布

weixin_34228662

最新推荐文章于 2023-03-26 19:49:26 发布

阅读量150

点赞数

文章标签：操作系统网络移动开发

原文链接：https://my.oschina.net/u/3863980/blog/2032785

版权

2019独角兽企业重金招聘Python工程师标准>>>

参考资料

<<精通Linux C编程>>

http://man7.org/linux/man-pages/man2/open.2.html

https://www.cnblogs.com/52php/p/5840229.html

在Android中的Handler的Native层研究文章中研究一下一把Linux中的匿名管道的通信机制，今天这里Linux中的进程间通信补齐。

在Linux中，实现进程通信的方法包括管道(匿名管道和具名管道)，消息队列，信号量，共享内存，套接口等。消息队列，信号量，共享内存统称为系统的(POSIX和System V)IPC，用于本地间的进程通信，套接口(socket)则运用于远程进程通信。

各个通信机制定义如下：

匿名管道(Pipe)和具名管道(named pipe)：匿名管道用于具有亲缘关系进程间的通信，具名管道克服了管道没有名字的限制，因此除了具有匿名管道的功能外，还允许在无亲缘关系的进程中进行通信。
消息队列(Message)：消息队列为消息的链接表，包括POSIX消息队列和System V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读取队列中的消息。
共享内存：是的多个进程可以访问同一块内存空间，是最快的可以IPC形式。是针对其他的通信机制运行效率较低而设计出来的。往往与其他通信机制，如信号量结合使用，来达到进程间的同步与互斥。
信号量(semaphore)：主要作为进程间以及同一进程不同线程的同步手段。
套接口(socket)：最一般的进程通信机制，可用于远程通信。

匿名管道与具名管道

关于匿名管道的理解以及Demo，在Android中的Handler的Native层研究文章中已经讲述过了，这里就不做介绍了。直接看具名管道(FIFO)。具名管道的提出是为了解决匿名管道只能用于具有亲缘关系(父子，兄弟)的进程间通信，具名管道提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中，即使没有亲缘关系的进程也可通过该路径名达到互相通信的目的。

匿名管道与FIFO的区别主要在如下俩个点：

FIFO可以用于任何两个进程的通信，而匿名管道只能用于有亲缘关系的进程中
FIFO作为一种特殊的文件存放于系统中，不像匿名管道存放于内存当中(使用后消失)。当进程对FIFO使用完毕后，FIFO依然存活于文件系统当中，除非主动删除，否则不会消失。

由于上面的第二个特性，可以解决系统在应用中产生的大量的中间临时文件的问题，达到重用的目的。

创建一个命令管道可以使用如下两个命令创建：


#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename, mode_t mode);
int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0); //不建议使用了

关于mode_t，看过其实就是文件访问权限表示，在鸟哥linux私房菜的权限一章中有介绍，这里就不讲了，详细的自己查看链接吧，下面简单实现一个Demo：



#include<iostream>
#include<signal.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<errno.h>

void testNamePipe(){
    mode_t mode=0666;
    const char* name="namePipeTest";
    int ret=mkfifo(name,mode);
    if(errno==EEXIST){

        printf("对象存在");
    }else if(ret<0){

        printf("创建命名管道失败，自动退出");
        exit(1);
    }else{
    
        printf("创建命名管道成功");
        
    }

}

编译需要加入-lrt 如g++ main.cpp -lrt -o main

对于管道的操作如下：

open()：打开命名管道
read()：读取命名管道数据
write()：向命名管道写入数据
close()：关闭命名管道
unlink()：删除命名管道

在操作命令管道open()函数的传参主要实现有如下几种：

open(const char *path, O_RDONLY); // 1

open(const char *path, O_RDONLY | O_NONBLOCK); // 2

open(const char *path, O_WRONLY); // 3

open(const char *path, O_WRONLY | O_NONBLOCK); // 4

引用自这篇文章

在open函数的调用的第二个参数中，你看到一个陌生的选项 O_NONBLOCK，选项 O_NONBLOCK 表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的。

open调用的阻塞是什么一回事呢？很简单，对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

简单实现阻塞的Demo如下，这里直接使用父子进程进行测试：

#include <errno.h>
#include <fcntl.h> //O_WRONLY等头文件
#include <iostream>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
const char* name = "namePipeTest";
void rwNamePipe()
{
    int pid = -1;
    if ((pid = fork()) < 0) {
        printf("%s", "fork error");
    } else if (pid == 0) {
        //子进程
        printf("%s\n", "子进程创建成功");
        int writeId = open(name, O_WRONLY); //以只写的形式
        if (writeId < 0) {
            printf("写端打开失败");
            exit(1);
        } else {
            printf("写端打开成功");
            char buf[] = "hello named pipe";
            for (int i = 0; i < 10; i++) {
                cout << "写入数据中" << endl;
                write(writeId, buf, sizeof(buf));
                sleep(2); //睡眠两秒
            }
            close(writeId);
            exit(0);
        }
    } else {
        //父进程，即当前进程
        printf("%s\n", "父进程开始作业");
        int readId = open(name, O_RDONLY);
        if (readId < 0) {
            printf("读端打开失败");
            exit(1);
        } else {

            printf("开始进入读取数据阶段");
            char buffer[1024];
            while (read(readId, buffer, sizeof(buffer)) > 0) {
                printf("父进程读到数据=%s\n", buffer);
            }
            close(readId);
            exit(0);
        }
    }
}
void testNamePipe()
{
    mode_t mode = 0666;//owner，group,others都有读写权限
    int ret = mkfifo(name, mode);
    if (errno == EEXIST) {
        printf("对象存在");
        rwNamePipe();
    } else if (ret < 0) {

        printf("创建命名管道失败，自动退出");
        exit(1);
    } else {

        printf("创建命名管道成功");
        rwNamePipe();
    }
}
int main()
{
    testNamePipe();
    return 0;
}

得到的结果：

$ ./main 
对象存在父进程开始作业
对象存在子进程创建成功
写端打开成功写入数据中
开始进入读取数据阶段父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe
写入数据中
父进程读到数据=hello named pipe

POSIX消息队列

消息队列为以一种链表式结构组织的一组数据，存放于内核之中，由个进程通过消息队列标识符引用传递数据的一种方式，由内核维护。消息队列为最具有数据操作性的数据床送方式，在消息队列中可以随意的根据特定的数据类型来检索消息。

消息队列跟匿名管道以及FIFO的区别(来自该篇文章)：

一个进程向消息队列写入消息之前，并不需要某个进程在该队列上等待该消息的到达，而管道和FIFO是相反的，进程向其中写消息时，管道和FIFO必需已经打开来读，那么内核会产生SIGPIPE信号。
IPC的持续性不同。管道和FIFO是随进程的持续性，当管道和FIFO最后一次关闭发生时，仍在管道和FIFO中的数据会被丢弃。消息队列是随内核的持续性，即一个进程向消息队列写入消息后，然后终止，另外一个进程可以在以后某个时刻打开该队列读取消息。只要内核没有重新自举，消息队列没有被删除。

POSIX消息队列的相关操作(更详细的可以man各个函数查看)：

//打开一个消息队列
 mqd_t mq_open(const char *name, int oflag);
 mqd_t mq_open(const char *name, int oflag, mode_t mode,struct mq_attr *attr);
 //关闭消息队列
 int mq_close(mqd_t mqdes);
 //从系统中删除消息队列
 int mq_unlink(const char *name);
//获取以及设置消息队列属性
int mq_getattr(mqd_t mqdes, struct mq_attr *attr);
int mq_setattr(mqd_t mqdes, struct mq_attr *newattr,  struct mq_attr *oldattr); 
//man查阅可知
struct mq_attr {
               long mq_flags;       /* Flags: 0 or O_NONBLOCK */
               long mq_maxmsg;      /* Max. # of messages on queue */
               long mq_msgsize;     /* Max. message size (bytes) */
               long mq_curmsgs;     /* # of messages currently in queue */
           };
//发送以及接收消息
int mq_send(mqd_t mqdes, const char *msg_ptr,   size_t msg_len, unsigned msg_prio); 
ssize_t mq_receive(mqd_t mqdes, char *msg_ptr,  size_t msg_len, unsigned *msg_prio);

测试代码如下：

测试中遇到了两个问题记录如下：

在调用mq_receive()时候遇到了Message too long的问题，主要是因为主要原因在于传递的msg_len小于mq_msgsize导致，详细可查看文章1以及文章2。
在mq_open()时候爆出invalid argument错误，原因是不同ubuntu系统中对于mq_attr支持的设置不一样，可通过文章3查看系统支持的参数大小

测试Demo:

#ifndef MES_QUEUE_H_
#define MES_QUEUE_H_

#include <fcntl.h>
#include <iostream>
#include <mqueue.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
using namespace std;

void receiveQueue(string name)
{
    cout << "客户端读取消息-----------------------" << endl;
    mode_t mode = 0666;
    struct mq_attr att;
    att.mq_msgsize = 30;
    att.mq_maxmsg = 10;
    att.mq_curmsgs = 0;
    att.mq_flags = 0;
    mqd_t openId = mq_open(name.c_str(),O_RDWR  | O_CREAT|O_EXCL, mode,&att );
    if (openId < 0 && errno != EEXIST) {
        cout << "error open mq:" << strerror(errno) << endl;
        return;
    }
    if(openId<0&&errno==EEXIST){
        cout<<"文件存在打开"<<endl;
        openId=mq_open(name.c_str(),O_RDONLY);
        if(openId<0){
            cout<<"打开失败:"<<strerror(errno)<<endl;
            return;
        }
    }
    struct mq_attr attr;
    if (mq_getattr(openId, &attr) < 0) {
        cout << "error get attr" << endl;
        return;
    } else {
        printf("flags: %ld, maxmsg: %ld, msgsize: %ld, curmsgs: %ld\n",
                attr.mq_flags, attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);
    }
    char buffer[50];
    cout << "开始读取消息" << endl;
    while (true) {
        if(mq_receive(openId, buffer,50, NULL)>=0){
            printf("读取的消息是：%s\n", buffer);
        }else{
            //cout<<strerror(errno)<<endl;
        
        }

    }
    mq_close(openId);
}
void sendQueue(string name)
{
    cout << "服务端发送消息----------------------" << endl;
    mqd_t openId = mq_open(name.c_str(),O_RDWR);
    if (openId < 0) {
        cout << "error open mq" << errno << endl;
        return;
    }
    struct mq_attr attr;
    if (mq_getattr(openId, &attr) < 0) {
        cout << "error get attr" << endl;
        fprintf(stderr, "发送失败: %s\n", strerror(errno));
        return;
    } else {
        printf("flags: %ld, maxmsg: %ld, msgsize: %ld, curmsgs: %ld\n",
                attr.mq_flags, attr.mq_maxmsg, attr.mq_msgsize, attr.mq_curmsgs);
    }
    //int size=static_cast<int>(attr.mq_msgsize);
    cout << "开始发送消息" << endl;

    for (int i = 0; i < 10; i++) {
        string result = "msq no: " + to_string(i);
        const char* msg_ptr = result.c_str();
        cout<<"发送消息中"<<endl;
        int rec = mq_send(openId, msg_ptr, strlen(msg_ptr)+1, 1);
        if (rec < 0) {
            cout << "发送信息失败" << rec << endl;
            fprintf(stderr, "发送失败: %s\n", strerror(errno));

            break;

        } else {
            cout << "写入消息为" << result << endl;
        }
        sleep(3);
    }
    cout<<"发送完毕"<<endl;
    mq_close(openId);
}
void runMsgQueue()
{
    string name = "/msq_test";
    int pid = -1;
    if ((pid = fork()) < 0) {
        printf("%s", "fork error");
        exit(1);
    } else if (pid == 0) {
        //子进程
        sendQueue(name);
    } else {
        //本进程
        receiveQueue(name);
    }
}
#endif

输出结果如下:

$ ./main                   
客户端读取消息-----------------------
flags: 0, maxmsg: 10, msgsize: 30, curmsgs: 0
开始读取消息
服务端发送消息----------------------
flags: 0, maxmsg: 10, msgsize: 30, curmsgs: 0
开始发送消息
发送消息中
写入消息为msq no: 0
读取的消息是：msq no: 0
发送消息中
写入消息为msq no: 1
读取的消息是：msq no: 1
发送消息中
写入消息为msq no: 2
读取的消息是：msq no: 2
发送消息中
写入消息为msq no: 3
读取的消息是：msq no: 3
发送消息中
写入消息为msq no: 4
读取的消息是：msq no: 4
发送消息中
写入消息为msq no: 5
读取的消息是：msq no: 5
发送消息中
写入消息为msq no: 6
读取的消息是：msq no: 6
发送消息中
写入消息为msq no: 7
读取的消息是：msq no: 7
发送消息中
写入消息为msq no: 8
读取的消息是：msq no: 8
发送消息中
写入消息为msq no: 9
读取的消息是：msq no: 9
发送完毕

额外提个tip，这里队列可以理解成优先级队列的概念,在我们mq_send()最后一个参数为优先级，在服务端receive的时候会按照优先级进行读取，而不是客户端最先发送的。

POSIX信号量

信号量（semaphore）是一种提供不同进程间或者一个给定进程不同线程之间的同步，这里依然分为POSIX信号量和SystemV信号量，文章中只对POSIX信号量进行学习归纳。

在POSIX信号量中，分为有名信号量和无名信号量：

有名信号量：使用Posix IPC名字标识，既可用于线程间的同步，又可以用于进程间的同步。
无名信号量：无名信号量只存在于内存中，并且规定能够访问该内存的进程才能够使用该内存中的信号量。这就意味着，无名信号量只能被这样两种线程使用：（1）来自同一进程的各个线程（2）来自不同进程的各个线程，但是这些进程映射了相同的内存范围到自己的地址空间。

总而言之，无名信号量一般用于线程间同步或互斥，而有名信号量一般用于进程间同步或互斥。

有名信号量和无名信号量的使用区别如下：

图片引用

有名信号量

有名信号量的头文件在semaphore.h中，具体涉及的函数如下所示：

注： Link with -pthread



sem_open()        //初始化并打开有名信号量
sem_wait()/sem_trywait()/sem_timedwait()/sem_post()/sem_getvalue()    //操作信号量
sem_close()       //退出有名信号量
sem_unlink()      //销毁有名信号量

打开一个有名信号量：

//传入参数参考消息队列的mq_open()中相对应参数，value参数用来指定信号量的初始值，取值范围[0，SEM_VALUE_MAX]
sem_t *sem_open(const char *name, int oflag);
sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);

操作有名信号量：

//成功返回降低后的信号量的值，失败返回-1以及errno
//试图占用信号量，如果信号量值>0,就-1,如果已经=0,就block，直到>0
int sem_wait(sem_t *sem);

//试图占用信号量，如果信号量已经=0，立即报错
int sem_trywait(sem_t *sem);

//试图占用信号量
//如果信号量=0,就block abs_timeout那么久，超时则报错
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

//归还信号量，成功返回0,失败返回-1，以及errno
int sem_post(sem_t *sem);

//获得信号量sem的当前的值，放到sval中。如果有线程正在block这个信号量，sval可能返回两个值，0或“-正在block的线程的数目”，Linux返回0
//成功返回0,失败返回-1以及errno

int sem_getvalue(sem_t *sem, int *sval);

关闭有名信号量：

//关闭有名信号量，成功返回0,失败返回-1以及errno
int sem_close(sem_t *sem);

删除有名信号量：

//试图销毁信号量，一旦所有占用该信号量的进程都关闭了该信号量，那么就会销毁这个信号量，成功返回0,失败返回-1以及errno
int sem_unlink(const char *name);

这里选择使用线程进行测试，测试Demo如下：

#ifndef SEMAPHORE_TEST_H_
#define SEMAPHORE_TEST_H_
#include<iostream>
#include<fcntl.h>
#include<unistd.h>
#include <semaphore.h>
#include <pthread.h>
#include <sys/stat.h>
#include<string.h>
using namespace std;
static sem_t* sem;
void *runChildThread(void* arg)
{
    int * id=static_cast<int*>(arg);
    int pid=*id;
    cout<<"pid="<<pid<<"的线程等待信号量"<<endl;
    sem_wait(sem); //申请信号量
    cout<<"pid="<<pid<<"获得信号量"<<endl;
    sleep(2);
    sem_post(sem); /*释放信号量*/
    cout<<"pid="<<pid<<"释放信号量"<<endl;
}




void runSemaphoreTest()
{
    string name="/sem_test";
    mode_t mode=0666;
    uint value=1;
    sem= sem_open(name.c_str(),O_CREAT,mode,value);
    if(sem==SEM_FAILED){
        cout<<"create name sem error："<<strerror(errno)<<endl;
        return;
    }
    cout<<"成功创建信号量"<<endl;
    pthread_t tid=12;
    for(int i=0;i<10;i++){
        int result= pthread_create(&tid,NULL,runChildThread,&i);
        if(result!=0){
            cout<<"创建线程失败，程序退出"<<endl;
            exit(1);
        }
    }

    sleep(30);//测试线程执行
	sem_close(sem);
}

#endif

结果如下：


$ ./main
成功创建信号量
pid=1的线程等待信号量
pid=1获得信号量
pid=2的线程等待信号量
pid=3的线程等待信号量
pid=4的线程等待信号量
pid=5的线程等待信号量
pid=6的线程等待信号量
pid=7的线程等待信号量
pid=8的线程等待信号量
pid=9的线程等待信号量
pid=10的线程等待信号量
pid=1释放信号量
pid=2获得信号量
pid=2释放信号量
pid=3获得信号量
pid=3释放信号量
pid=4获得信号量
pid=4释放信号量
pid=5获得信号量
pid=5释放信号量
pid=6获得信号量
pid=6释放信号量
pid=7获得信号量
pid=7释放信号量
pid=8获得信号量
pid=8释放信号量
pid=9获得信号量
pid=9释放信号量
pid=10获得信号量
pid=10释放信号量

上述Demo的信号量的数量设置为1，只有一个线程能获取到信号量进入代码执行，其他线程需要等待当前线程释放信号量后，然后进行抢夺信号量，或得到的线程进行代码执行，依次进行下去，如果把sem_open()的value参数改成三则说明最多三个线程可以同时进行，这里就不写Demo了。

需要注意的一点是有名信号量的值是随内核持续的。也就是说，一个进程创建了一个信号量，这个进程结束后，这个信号量还存在，并且信号量的值也不会改变。

无名信号量

无名信号量由于没有名字，所以使用方法与有名信号量略有不同，却别主要在创建以及销毁的操作上，区别的函数如下：

sem_init()        //创建/获得无名信号量
sem_destroy()     //销毁无名信号量

测试的Demo可以把对应有名信号量的方法换成上述两个方法即可，就不详细介绍了。

共享内存

内核管理一片物理内存，允许不同的进程同时映射，多个进程可以映射同一块内存，被多个进程同时映射的物理内存，即共享内存。由于本身实现并不能保证同步，所以需要我们自己进行同步，最常见的是使用信号量的方式进行同步。

使用说明：


#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
void *shmat(int shm_id, const void *shm_addr, int shmflg);
int shmdt(const void *shm_addr);
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

由于共享内存本身不涉及进程通信，就不给出Demo了，想要了解使用方式的可以百度一下。

套接字

套接字，就是我们的Socket，通过套接字，我们可以实现本地或者远程两个进程之间的通信，在网络编程中经常能遇见Socket编程。上面介绍的进程通信局限于本机的进程之间通信，而Socket则主要实现远端与本机的进程通信。

这里简单介绍一下Socket与Http的区别把。在大学里都学过网络由下往上分为，物理层、数据链路层、网络层、传输层、会话层、表示层和应用层，一般来说我们把会话层，表示层和应用层统称为应用层。IP协议对应于网络层，TCP协议对应于传输层，而HTTP协议在应用层。如图下所示([图片来自网络)：

图片来自网络

而Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，封装了TCP/IP的调用实现，当然也支持UDP协议。http的本质实现上也需要依赖Socket进行通信。

关于linux下的Socket通信用法，网上写的文章我觉得比我整理学习的好的多，再次放上几个链接把(吐个槽，网上基本一篇文章复制来复制去的)，就不整理了，要整理的话不是一篇文章可以写的。其实最好就是看文档了，用man命令是非常值得拥有的。

https://segmentfault.com/a/1190000010838127

https://www.cnblogs.com/jiangzhaowei/p/8261174.html

针对TCP放上Demo，linux下使用c++开发服务端，使用JAVA充当客户端《服务端如下：


#ifndef SOCKET_TEST_H_
#define SOCKET_TEST_H_
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include<iostream>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<unistd.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <sys/ioctl.h>
#define PORT 9876
#define MAXLINE 4096
using namespace  std;


void getSockName(int& sock){

   struct sockaddr_in addr;
   socklen_t addr_len = sizeof(struct sockaddr_in);

   /* 获取本端的socket地址 */
   int nRet = getsockname(sock,(struct sockaddr*)&addr,&addr_len);
   if(nRet == -1)
   {
       perror("getsockname error: ");
   }else{

       printf("this socket addr %s %d successful\n",inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));

   }


}
void startServer(){
   //ipv4
   int socketFd=socket(AF_INET,SOCK_STREAM,0);
   if(socketFd==-1){
       cout<<"open socket error: "<<strerror(errno)<<endl;
       exit(1);
   }
   cout<<"创建socket成功"<<endl;
   struct sockaddr_in addr;
   addr.sin_family = AF_INET;
   //如果使用INADDR_ANY方式，需要加以判断
   //是否符合网络字节序，即大端的传输方式，如果机器为小端，
   //需要通过htonl转换成网络字节序相配的，如果使用inet_addr()方法
   //，无需考虑大小端的问题
   addr.sin_addr.s_addr =(inet_addr("192.168.199.244"));
   addr.sin_port = htons(PORT);
   //绑定
   int bindStatus=bind(socketFd,(struct sockaddr*)&addr,sizeof(addr));
   getSockName(socketFd);
   if(bindStatus==-1){
       cout<<"bind error  "<<strerror(errno)<<endl;
       exit(1);
   }
   cout<<"绑定接口ok"<<endl;
   if(listen(socketFd,10)==-1){
       cout<<"开启监听失败"<<endl;
       exit(1);
   }
   char buffer[50];
   while(1){
       memset(buffer,0,50);
       cout<<"开始接收"<<endl;
       int isAccept=accept(socketFd, (struct sockaddr*)NULL, NULL);
       if( isAccept== -1){
           cout<<"接收失败"<<strerror(errno)<<endl;
           exit(1);
       }
       int result=recv(isAccept,buffer,MAXLINE,0);
       if(result==-1){
           cout<<"接收消息失败"<<strerror(errno)<<endl;
           exit(1);
       }
       string bufferStr=buffer;
       close(isAccept);
       if(bufferStr=="over"){
           cout<<"收到over信号，关闭服务端"<<endl;
           break;
       }else{
           printf("接收到的消息为:%s\n",buffer);
       }
   }
   close(socketFd);
}

#endif

客户端代码：


 private static void startClient(){

       new Thread(() -> {
           try {
               Socket socket = new Socket("192.168.199.244",9876);
               //2.拿到客户端的socket对象的输出流发送给服务器数据
               OutputStream os = socket.getOutputStream();
               //写入要发送给服务器的数据
               os.write(("over" ).getBytes(StandardCharsets.UTF_8));
               os.flush();
              os.close();
              socket.close();
           } catch (IOException e) {
               e.printStackTrace();
               System.out.print("socket connect erro");
           }
       }).start();


   }

最终输出结果：


创建socket成功
this socket addr 192.168.199.244 9876 successful
绑定接口ok
开始接收
接收到的消息为:01234
开始接收
收到over信号，关闭服务端

转载于:https://my.oschina.net/u/3863980/blog/2032785

weixin_34228662

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
linux上的进程通信学习笔记

2019独角兽企业重金招聘Python工程师标准>>> ...
复制链接

扫一扫