linux C进程常用操作

不登高山，不知天之高也； 

不临深溪，不知地之厚也。

荀子《劝学》

 linux应用层主要是一个个独立任务的进程在运行，但是很多时候，在工作中我们可能很少去重新写一个进程，

大部分的工作都是分配到了一个进程内的模块或者提供进程内特定功能的接口开发，这篇文章是想简单说明下，

作为一个进程，在实际开发过程中，可能用到的一些编程方法比如：main参数解析，信号注册、回调函数、

线程创建、文件操作（FIFE *fp）、进程间通信（socket）；每一种我都会附一个简单的实例。

1、main参数解析，参数较少，使用简单判断argc并取出对应的argv[i]值就就可以处理，代码如下：

#include <stdio.h>
int main(int argc, char *argv[])
{
  int i = 0;
  printf("argc is %d
", argc);
  for(i = 0; i < argc; i++)
    printf("argv[%d] is %s
", i, argv[i]);
  return 0;
}

参数较多时就可以调用getopt/getopt_long接口来完成工作。

函数的定义

int getopt(int argc, char * const argv[], const char *optstring);

参数说明：

argc：main()函数传递过来的参数的个数

argv：main()函数传递过来的参数的字符串指针数组

optstring：选项字符串，告知 getopt()可以处理哪个选项以及哪个选项需要参数

代码样列

#include<stdio.h>
#include<unistd.h>
#include<getopt.h>
int main(int argc, char *argv[])
{
    int opt;
    /*单个字符表示选项没有参数                  输入格式：-A即可，不加参数
     *单字符加冒号表示选项有且必须加参数        输入格式：-B xiaocang或-Bxiaobo(二选一)
     *单字符加两个冒号表示选项可以有也可以无    输入格式：-Cxiaobo(必须挨着)
     */
    char *string = "AB:C::";
    while ((opt = getopt(argc, argv, string))!= -1)
    {  
        /* 下面是常用的两个获取选项及其值得变量optarg无需定义，全局变量
         * opt          '-' 后面的字符，也就是参数字符
         * optarg       指向当前选项参数(如果有)的指针。
         */
        printf("opt = %c		", opt);
        printf("optarg = %s		
", optarg);
    }
    return 0;
}

样列输出：

./argc-opt -A -B xiaocang -Cxiaobo
opt = A    optarg = (null)    
opt = B    optarg = xiaocang    
opt = C    optarg = xiaobo

2、信号注册，作为一个进程，很有必要注册一定的信号，防止进程异常退出时，自己蒙圈。

函数定义：

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

参数说明：

signum：要捕捉的信号（查看信号：kill -l，9号SIGKILL信号不能被捕捉）; 

handler：我们要对信号进行的处理方式。

示例代码：

#include <stdio.h>
#include <signal.h>
void signal_handler(int signal)
{
    printf("Received signal %d
", signal);
    printf("do something...
");
    return;
}
int main(int argc, char *argv[])
{
    signal(SIGHUP, signal_handler);
    while(1)
        sleep(2000);
    return 0;
}

示例测试：

一个窗口后台挂进程运行 ./a.out &

开另外的窗口发送信号 kill -1 pid（a.out进程号）

第一个窗口收到将会收到 

Received signal 1 

do something...

3、回调函数

        其实在信号注册中我们就使用了回调函数，但是此回调函数不是我们自己定义的类型，自己用来调用执行，

我们这里做一个回调函数的调用示例，差别就在于回调函数的定义与调用时机，根据自己的实际需要定义就可以。

#include <stdio.h>

/* 定义一个函数指针 确定入参与返回值类型 */
typedef int (* MyCallbak)(int PanJinLian, int XiMengQin);
/* 实现一个与上面定义的函数指针入参与返回值类型相同的函数 */
int ThisMyFunc(int PanJinLian, int XiMengQin)
{
    printf("PanJinLian is %d
", PanJinLian);
    printf("XiMengQin is %d
", XiMengQin);
    printf("do something...
");
    return 0;
}
int main(int argc, char *argv[])
{
    int P_adrenaline = 99;
    int X_adrenaline = 101;
    MyCallbak CallbakPointer;/* 定义一个函数指针变量 */
    CallbakPointer = ThisMyFunc;/* 将函数地址赋予定义的指针 也叫挂钩子*/
    int ret = CallbakPointer(P_adrenaline, X_adrenaline);/* 调用函数，执行回调 */
    printf("ret is %d
", ret);
    return 0;
}

执行返回

PanJinLian is 99
XiMengQin is 101
do something...
ret is 0

4、线程创建

       线程主要是用来阻塞接受异步消息，或者完成耗时与周期性的任务，重点需要关注的是线程结束时线程资源的回收问题，

很多人会忽略这部分，会用到 pthread_detach 或者 pthread_join（阻塞等待线程结束并回收资源）; 多线程必将引入同步与

互斥问题，则对于全局变量，必须要加锁保护，数据流防止丢失我们会用到队列。

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                    void *(*start_routine) (void *), void *arg)
//Compile and link with -pthread.

参数说明

thread：指向线程标识符的指针。

attr：用来设置线程属性。

start_routine：线程运行函数的起始地址。

arg：运行函数的参数。

样例代码：

#include<stdio.h>
#include <pthread.h>
static void mythreadfun( void *arg )
{
    /*这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源*/
    pthread_detach(pthread_self());
    printf("arg is %s
", (char *)arg);
    int i = 0;
    while(1)
    {
        printf("do something...
");
        if(i++ == 10)
            break;
        sleep(2);
    }
    return ;
}

int main(int argc, char *argv[])
{
    pthread_t pthreadid = 0;
    int ret = 0;
    char *param = "good";
    /* 创建线程 */
    ret = pthread_create(&pthreadid, NULL, (void *)mythreadfun, (void *)param);
    if(ret != 0)
    {
        printf("create pthread failed.");
        return;
    }
    printf("create pthread success.");
    while(1)
        sleep(2000);
    return 0;
}

执行返回

./a.out
create pthread success.arg is good
do something...
do something...
do something...
do something...

5、文件操作，文件操作很普遍，如记录数据，读入数据等。

文件操作一般要注意，明确操作的fp在文件中的位置，fclose前刷新缓存，对写入或者读出的返回做判断，异常或者结束

操作时关闭fp，同样还有open read write接口。两者区别：

1、缓冲文件系统与非缓冲系统的区别

缓冲文件系统(fopen)：在内存为每个文件开辟一个缓存区，当执行读操作，从磁盘文件将数据读入内存缓冲区，装满后从

内存缓冲区依次读取数据。写操作同理。

内存缓冲区的大小影响着实际操作外存的次数，缓冲区越大，操作外存的次数越少，执行速度快，效率高。缓冲区大小由机

器而定。借助文件结构体指针对文件管理，可读写字符串、格式化数据、二进制数据。

非缓冲文件系统(open)：依赖操作系统功能对文件读写，不设文件结构体指针，只能读写二进制文件。

2、open属于低级IO，fopen属于高级IO

3、open返回文件描述符，属于用户态，读写需进行用户态与内核态切换。  fopen返回文件指针

4、open是系统函数，不可移植  fopen是标准C函数，可移植

5、一般用fopen打开普通文件，open打开设备文件

6、如果顺序访问文件，fopen比open快、 如果随机访问文件，open比fopen快

#include <stdio.h>
#include <string.h>
int main()
{
   FILE *fp;
   char *msg = "hello world";
   char buffer[20];
   fp = fopen("test.txt", "w+");/* 打开文件用于读写 */
   fwrite(msg, strlen(msg) + 1, 1, fp);/* 写入数据到文件 */
   fseek(fp, 0, SEEK_SET);/* 移动到文件的开头 */
   fread(buffer, strlen(msg) + 1, 1, fp); /* 读取并显示数据 */
   printf("%s
", buffer);
   fsync(fileno(fp));/* 刷新缓存 */
   fclose(fp);
   return(0);
}

执行结果

hello world
cat test.txt    
hello world

6、进程间通信：包括管道(pipe)、有名管道(named pipe)、信号量(semophore)、消息队列(message queue)、

信号(signal)、共享内存(shared memory)、套接字(socket)，这里只说下socket，tcp服务端与客户端的简单编

码流程实现。

server端

#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#define SERVER_SOCKET_FILE  "/tmp/server_socket"
int main()
{
    int ret = 0;
    int listen_fd = -1;
    int size = 0;
    int conn_fd = -1;
    int max_fd = 0;
    fd_set reads;
    struct sockaddr_un clt_addr;
    socklen_t len = sizeof(clt_addr);
    struct sockaddr_un srv_addr;
    unsigned char buf[4096];

    listen_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    if(listen_fd < 0)
    {
        printf("can not create listen socket
");
        return -1;
    }

    srv_addr.sun_family = AF_UNIX;
    strncpy(srv_addr.sun_path, SERVER_SOCKET_FILE, sizeof(srv_addr.sun_path));
    unlink(SERVER_SOCKET_FILE);
    ret = bind(listen_fd,(struct sockaddr*)&srv_addr, sizeof(srv_addr));
    if(ret < 0)
    {
        printf("can not bind server socket");
        close(listen_fd);
        return -1;
    }

    ret = listen(listen_fd, 5);
    if(ret < 0)
    {
        printf("can not listen the client");
        close(listen_fd);
        return -1;
    }
    while(1)
    {
        FD_ZERO(&reads);
        FD_SET(listen_fd, &reads);
        max_fd = listen_fd;
        if(conn_fd > 0)
        {
            FD_SET(conn_fd, &reads);
            if(conn_fd > max_fd)
            {
                max_fd = conn_fd;
            }
        }
        ret = select(max_fd+1, &reads, 0, 0, NULL);
        if(ret <= 0)
        {
            perror("select fail
");
            return -1;
        }
        else
        {
            memset(buf, 0, sizeof(buf));
            if(FD_ISSET(listen_fd, &reads))
            {
                conn_fd = accept(listen_fd, (struct sockaddr*)&clt_addr, &len);
            }
            if(FD_ISSET(conn_fd, &reads))
            {
                printf("recv client msg,conn_fd:%d
",conn_fd);
                read(conn_fd, buf, sizeof(buf));
                sleep(3);
                write(conn_fd, "i am server", strlen("i am server"));
            }
        }
    }
}

client端

#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#define SERVER_SOCKET_FILE  "/tmp/server_socket"
int main()
{
    int ret = 0;
    int retry = 5;
    int i = 0;
    int client_fd = 0;
    struct sockaddr_un server_addr;
    char buff[4096] = {0};
    int  recv_data_len = 0;
    struct sockaddr_un client_addr;
    socklen_t sock_len = sizeof(client_addr);
    if ((client_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
    {
        printf("create sockfd failed
");
        return -1;
    }
    printf("update socket create success.
");
    memset(&server_addr,0x00,sizeof(server_addr));
    server_addr.sun_family = AF_UNIX;
    strncpy(server_addr.sun_path, SERVER_SOCKET_FILE, strlen(SERVER_SOCKET_FILE));
    for(i = 0; i < retry; i++)
    {
        ret = connect(client_fd,(struct sockaddr*)&server_addr,sizeof(server_addr));
        if(0 != ret)
        {
            printf("cannot connect to the server, retry %d time.
", i);
            sleep(1);
            continue;
        }
        else
        {
            printf("connect server success.
");
            break ;
        }
    }
    write(client_fd, "hello", strlen("hello"));
    while(1)
    {
        memset(buff, 0, sizeof(buff));
        recv_data_len = recvfrom(client_fd, buff, sizeof(buff), 0, (struct sockaddr *)&client_addr, &sock_len);
        if(recv_data_len <= 0)
        {
            sleep(1); //sleep 100ms and receive from socket again
            printf("recv_data_len is %d.
", recv_data_len);

            /* 重新连接 省略*/
            close(client_fd);
            continue;
        }
        printf("recv data [%s]
", buff);
        /* do something */
        sleep(1);
        write(client_fd, "recv data form server", strlen("recv data form server"));
    }
    return 0;
}

分别编译命名server client，先运行server 后运行client即可如下所示：

 以上就是linux c进程，会涉及到的一些基本的操作，还有很多的比较重要且基本的内容没有这里并没有讲到。

       接触了不少项目，总结下来大型项目中涉及多进程，多线程，难点在于弄清楚通信消息的流向、数据结构的巧妙定义。剩下

的其实就是特定任务的逻辑部分了，如果作者有很好的注释或者编码规范，那理解起来也是很快的，添加功能也是很容易的事情。

万变不离其宗。搞清楚基本的内容、基本原理，我认为在技术成长中很重要。

 关注微信公众号【嵌入式C部落】，获取更多精华文章，海量编程资料，让我们一起进步，一起成长。