文档章节

linux上的进程通信学习笔记

JerryLin123
 JerryLin123
发布于 2018/09/09 23:38
字数 5676
阅读 36
收藏 6

参考资料

<<精通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信号,关闭服务端

© 著作权归作者所有

JerryLin123
粉丝 9
博文 67
码字总数 147047
作品 0
东城
私信 提问
Linux内核源码学习 (0)- 源代码的结构

截止2012年11月4日,Linux的最新稳定版本为3.6.5,可以从Linux官方网站(http://www.kernel.org/)下载最新的版本,我所研究的内核版本是2.6.34.13,这一系列笔记都是对这个版本的内核进行分...

notishell
2013/01/02
263
0
Linux基础01-分时操作系统简述

之前对Linux没有系统学习,因为要学习大数据,所以现在要系统学习了,在这里分享下心得、笔记,大家一块交流。 Linux是分时操作且支持多用户的系统,又称分时操作系统。 看似简单的几句话,但...

晓寞
2018/06/28
0
0
Linux学习笔记——管道PIPE

管道:当从一个进程连接数据流到另一个进程时,使用术语管道(pipe)。 # include int pipe(int filedes[2]); //创建管道 pipe()说明: 返回值:0成功,-1出错。 如果调用成功,则进程此时由了...

长平狐
2013/01/06
73
0
《Linux内核设计与实现》读书笔记 - 目录 (完结)

《Linux内核设计与实现》读书笔记 - 目录 (完结) 读完这本书回过头才发现, 第一篇笔记居然是 2012年8月发的, 将近一年半的时间才看完这本书(汗!!!). 为了方便以后查看, 做个《Linux内核设计...

你的猫大哥
2018/01/14
0
0
小蚂蚁学习Linux(1)——Linux简单介绍、VMware虚拟机的简单介绍

今天开始学习Linux,很久很久以前倒是学习过Linux,当时学的还挺认真,奈何长时间不用,记忆力又不给力,果断还是给忘的差不多了,当年的笔记也不知道遗失在了哪一个小角落里,不管怎么样吧,...

嗜学如命的小蚂蚁
2015/10/27
183
0

没有更多内容

加载失败,请刷新页面

加载更多

centos7 linuxdeployqt qt5.13.1 打包程序

原文链接:https://www.cnblogs.com/linuxAndMcu/p/11016322.html 一、简介 linuxdeployqt 是Linux下的qt打包工具,可以将应用程序使用的资源(如库,图形和插件)复制到二进制运行文件所在的...

shzwork
20分钟前
4
0
IDEA 配置Springboot项目热部署

实现的方式概述 注意以下的热部署方式在IDEA是默认没有打开自动编译的,手动编译需要快捷键(Ctrl+Shift+F9),自动编译的修改配置如下:(注意刷新不要太快,会有1-2秒延迟) File-Settings-C...

小强的进阶之路
31分钟前
5
0
免费数据分析工具:secsoso

前段时间思考了理想数据分析平台,之后我们根据这个思路开发了spl语言并提供了一个数据分析平台,这个平台主要用在搜索ES,数据库索引中的数据。但后来发现对文件的事后处理也是个非常重要的...

赛克蓝德
33分钟前
5
0
暗黑2不能正常启动?带你轻松使用WIN10运行游戏

暗黑破坏神2这款游戏由于年代比较久远,所以设置启动这方面与现在的大部分游戏有很大差距,由于当初完美运行暗黑2是当年使用最多的XP系统,在使用现在大多数玩家使用的WIN7到WIN10系统常会出...

太空堡垒185
37分钟前
6
0
maven项目对象模型(二)

1.4.4.传递性依赖 一个传递性依赖就是一个依赖的依赖。如果project-a依赖于project-b,而后者接着依赖于project-c,那么project-c就是被认为是project-a的传递性依赖。如果project-c依赖于p...

万建宁
37分钟前
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部