linux下多线程通信（一）

在linux下进行多线程编程，肯定会涉及到线程通信问题，本文主要分析pipe，即管道在多线之间通信实现。
#include
int pipe(int filedes[2]);
返回值：成功，返回0，否则返回-1。
参数数组包含pipe使用的两个文件的描述符。fd[0]:读管道，fd[1]:写管道

两个线程之间通信简单实现，单向pipe_1.c
源码地址：https://github.com/jeremy505/multi-thread-communication

#include 
#include 
#include 
#include 
Thread *m_Threads;
static int threadcount = 1;
void* work_thread(void* argc)
{
  Thread* param = (Thread*) argc;
  printf("childthread_tid=%lu\n", param->tid);
  int contant = 0;
  //sleep(2);
  printf("childthread--read return %d\n",read(param->notifyReceiveFd, &contant, sizeof(int)));
  printf("childthread--read from pipe %d\n", contant);
}

int main(int argc, char** argv)
{
     //在主线程和子线程之间建立管道
    m_Threads = malloc(sizeof(Thread) * threadcount);
    int fds[2];
    if( pipe(fds) )
    {
      perror("create pipe error");
    }
    m_Threads[0].notifyReceiveFd = fds[0];
    pthread_create(&m_Threads[0].tid, NULL,  work_thread, (void*)&m_Threads[0]);
    printf("mainthread_tid=%lu\n", m_Threads[0].tid);
    int contant = 1;
    // sleep(2);
    printf("mainthread--write %d to pipe\n", contant);
    printf("mainthread--write return %d\n",write(fds[1], &contant, sizeof(int)));
    pthread_join(m_Threads[0].tid, NULL);
    close(fds[0]);
    close(fds[1]);
    return 0;
}

以上只是单向通信，即主线程向子线程写int型值1，子线程读到int型值1.
输出见下：


可见，输出与设想的一致，只是此时通信只是单向，如果要实现双向，最简单的办法就是再创建一组pipe，实现pipe_1_d.c如下：

#include 
#include 
#include 
#include 
typedef struct __Thread
{
  pthread_t tid;    //线程的ID
  int notifyReceiveFd;  //管道的接收端
  int notifySendFd;   //管道的发送端
}Thread;

Thread *m_Threads;
static int threadcount = 1;
void* work_thread(void* argc)
{
  Thread* param = (Thread*) argc;
  printf("childthread_tid=%lu\n", param->tid);
  int contant = 0;
  //sleep(2);
  printf("childthread--read return %d\n",read(param->notifyReceiveFd, &contant, sizeof(int)));
  printf("childthread--read from pipe %d\n", contant);
  contant = 2;
  printf("childthread--write %d to pipe\n", contant);
  printf("childthread--write return %d\n",write(param->notifySendFd, &contant, sizeof(int)));
}

int main(int argc, char** argv)
{
     //在主线程和子线程之间建立管道
    m_Threads = malloc(sizeof(Thread) * threadcount);
    int fds[2];
    if( pipe(fds) )
    {
      perror("create pipe fds error");
    }
    int fds_1[2];
    if( pipe(fds_1) )
    {
      perror("create pipe fds_1 error");
    }
    m_Threads[0].notifyReceiveFd = fds[0];
    m_Threads[0].notifySendFd = fds_1[1];
     pthread_create(&m_Threads[0].tid, NULL,
                   work_thread, (void*)&m_Threads[0]);
    printf("mainthread_tid=%lu\n", m_Threads[0].tid);
    int contant = 1;
    // sleep(2);
    printf("mainthread--write %d to pipe\n", contant);
    printf("mainthread--write return %d\n",write(fds[1], &contant, sizeof(int)));
    printf("mainthread--read return %d\n",read(fds_1[0], &contant, sizeof(int)));
    printf("mainthread--read from pipe %d\n", contant);
    pthread_join(m_Threads[0].tid, NULL);
    close(fds[0]);
    close(fds[1]);
    close(fds_1[0]);
    close(fds_1[1]);
    }

另外创建一组pipe，主线读，子线程写。主线程先写1，然后阻塞等待子线程网管道中写值，子线程通过管道读到1之后往管道写2，此时管道有数据，主线程读取值2，输出如下：

以上只是简单的通过pipe线程之间进行同行，注意到读写都是阻塞的。如果不希望线程使用阻塞方式，一般会设置管道文件描述符为非阻塞，然后借助epoll或者select监听管道文件描述符读写事件。
线程之间通过pipe通信也可以应用到进程之间，在使用fork之后，管道描述符被拷贝了一份，所以父子进程必须关闭其中之一，假设父进程关闭读[close(fd[0])]，子进程就要关闭写[close(fd[1])]，，实现单向通信，反过来也是一样.
进程之间的通信，推荐一种方式使用共享内存，共享内存区是最快的IPC形式，此种方式也可在两个完全独立的程序之间进行数据传递，后续再详细介绍。
当然，进程以及线程之间的通信不止以上方法，还有使用socket，eventfd等。