出现这种情况大多是因为程序采用CS架构（服务器/客户端）在读写操作时出现，我第一次也是在这样的情况下遇到的。首先我们都知道套接字的通信方式是双工的，同端即可写也可读。而出现Broken pipe这种情况的原因是写端正在写入时，另一端已关闭套接字，这样进程就会向系统发送SIGPIPE信号，然后系统再回头叫停线程，这样就会出现管道破裂的信号并且退出程序。这虽然是进程的一种保护机制，但是在运行过程中一般我们是不希望出现退出程序的保护。于是便上网查了一番。发现在main函数开始加一行“signal(SIGPIPE， SIG_IGN);”代码即可意思是屏蔽SIGPIPE信号，但是加上后并没有起作用，依旧还是出现管道破裂错误。后来在网上看到有大神说是因为signal函数设置的信号处理只起一次作用，处理一次后就会再重置为默认处理，要用sigaction来设置自定义的信号处理方式“struct sigaction sa;sa.sa_handler = SIG_IGN;sigaction( SIGPIPE, &sa, 0 );”，于是我自行写了代码测试这种情况是不是如这位大神所说，发现并非如此，至少我用的这个开发板不是如此。于是又陷入在网上一番查找。

        最后决定把这种情况复现出来，这样更容易测试（这部分代码来自网络并自己修改的，如有侵权，请私信告诉我）

cli_test.c

#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

#define HELLO_WORLD_SERVER_PORT 6666
#define BUFFER_SIZE 1024

void a(void)
{
    printf("123456789\n");
}

int main(int argc, char **argv)
{
  if (argc != 2)
  {
    printf("Usage: ./%s ServerIPAddress\n",argv[0]);
    exit(1);
  }
  //signal(SIGPIPE, SIG_IGN);
  signal(SIGPIPE, a);
  //struct sigaction sa;
  //sa.sa_handler = SIG_IGN;
  //sigaction( SIGPIPE, &sa, 0 );

  struct sockaddr_in client_addr;
  bzero(&client_addr,sizeof(client_addr));
  client_addr.sin_family = AF_INET;
  client_addr.sin_addr.s_addr = htons(INADDR_ANY);
  client_addr.sin_port = htons(0);

  int client_socket = socket(AF_INET,SOCK_STREAM,0);

  if( client_socket < 0)
  {
    printf("Create Socket Failed!\n");
    exit(1);
  }

  if( bind(client_socket,(struct sockaddr*)&client_addr,sizeof(client_addr)))
  {
    printf("Client Bind Port Failed!\n");
    exit(1);
  }

  struct sockaddr_in server_addr;
  bzero(&server_addr,sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  if(inet_aton(argv[1],&server_addr.sin_addr) == 0)
  {
    printf("Server IP Address Error!\n");
    exit(1);
  }
  server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
  socklen_t server_addr_length = sizeof(server_addr);
  if(connect(client_socket,(struct sockaddr*)&server_addr, server_addr_length) < 0)
  {
    printf("Can Not Connect To %s!\n",argv[1]);
    exit(1);
  }

  char buffer[BUFFER_SIZE];
  bzero(buffer,BUFFER_SIZE);
  int length = recv(client_socket,buffer,BUFFER_SIZE,0);
  if(length < 0)
  {
    printf("Recieve Data From Server %s Failed!\n", argv[1]);
    exit(1);
  }
  printf("From Server %s :\t%s",argv[1],buffer);

  bzero(buffer,BUFFER_SIZE);
  strcpy(buffer,"Hello, World! From Client\n");

  while(1){
    sleep(1);
    int ret = send(client_socket,buffer,BUFFER_SIZE,/*MSG_NOSIGNAL*/0);
        if (ret == -1 && errno == EPIPE){
          printf("receive sigpipe\n");
          printf("receive %s\n", strerror(errno));
    }
  }

  close(client_socket);
  return 0;
}

ser_test.c

#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define HELLO_WORLD_SERVER_PORT 6666
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024

int main(int argc, char **argv)
{
  struct sockaddr_in server_addr;
  bzero(&server_addr,sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = htons(INADDR_ANY);
  server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);

  int server_socket = socket(AF_INET,SOCK_STREAM,0);
  if( server_socket < 0)
  {
    printf("Create Socket Failed!");
    exit(1);
  }

  if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
  {
    printf("Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT);
    exit(1);
  }

  if ( listen(server_socket, LENGTH_OF_LISTEN_QUEUE) )
  {
    printf("Server Listen Failed!");
    exit(1);
  }

  while (1)
  {
    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);

    int new_server_socket = accept(server_socket,(struct sockaddr*)&client_addr,&length);
    if ( new_server_socket < 0)
    {
      printf("Server Accept Failed!\n");
      break;
    }

    char buffer[BUFFER_SIZE];
    bzero(buffer, BUFFER_SIZE);
    strcpy(buffer,"Hello,World from server!");
    strcat(buffer,"\n");
    send(new_server_socket,buffer,BUFFER_SIZE,0);

    bzero(buffer,BUFFER_SIZE);
        while(1){
      length = recv(new_server_socket,buffer,BUFFER_SIZE,0);
      if (length < 0)
      {
        printf("Server Recieve Data Failed!\n");
        exit(1);
      }
      printf("\n%s",buffer);
        }
    close(new_server_socket);
  }
  close(server_socket);
  return 0;
}

Makefile

CC = arm-hisiv500-linux-gcc //我用的交叉编译工具，根据自己情况进行修改编译工具
#CC = gcc
#CFLAGS = -g -Wall -O3
SRCS = cli_test.c ser_test.c

SER = ser
CLI = cli

OBJS = $(SRCS:.c=.o)

%.o:%.c
    $(CC) $(CFLAGS) -o $@ -c $<

all:$(SER) $(CLI)
$(SER):ser_test.o
    $(CC) -o $@ $^

$(CLI):cli_test.o
    $(CC) -o $@ $^
    rm -rf *.bak

clean:
    rm -rf $(SER) $(CLI) $(OBJS) *.bak

        make编译，分别将ser端和cli端运行起来，正常接收信息后，Ctrl+c结束ser程序，cli端即出现管道破裂错误。

        最后经过测试发现上面提到过的两种屏蔽方式在gcc编译工具生成的文件都是可行的，都能屏蔽成功，唯独在arm-linux下不行。后来又找到一种临时可用的屏蔽方法，那就是将send的flags位（最后一位参数）传入MSG_NOSIGNAL，这是屏蔽send所产生的所有信号，当然包括段错误信号，这样就会很危险，当然也是一种临时可行的方法。

         后来发现用arm-linux和gcc两种编译及操作方式唯一不同的就是我在arm-linux上用了gdb调试，于是猜想会不会是gdb在搞鬼呢。于是不用gdb直接运行代码，经过测试发现还真的是gdb。

        后来再经过查找发现，原因是这样的，当进程出现Broken pipe错误时，会将该信号发送给系统，系统收到信号后会反过来再发给进程来叫停进程，当用gdb调试时，收到系统发的信号的并不是进程，而是让gdb给半路拦截下来了，当gdb收到信号后默认处理方式是暂停程序，将错误打印出来。这样一来我们的进程实际上并没有收到信号的情况下就被叫停了，所以在程序里面不管怎样处理信号都是做无用功。

        所以要想继续用gdb调试运行，则需要修改gdb对信号的处理方式，在用gdb启动程序后输入下面命令，

        handle SIGPIPE nostop

        在输入r运行程序，将不再出现Broken pipe错误