}2}YY@0DZ12E(B8$6~I`_QJ.png

1，文件操作

1.1普通文件操作：

使用open函数创建函数

       #include <sys/types.h>
       #include <sys/stat.h>
       #include <fcntl.h>

       int open(const char *pathname, int flags);
       int open(const char *pathname, int flags, mode_t mode);
       int creat(const char *pathname, mode_t mode);

函数功能：打开文件
函数参数：pathname：待打开文件的路径，flags：打开文件的模式
其中flags的参数有：
O_RDONLY 只读模式，
O_WRONLY 只写模式
O_RDWR 读写模式
O_CREAT 创建模式
O_TRUNC
O_EXCL
当flag中含有O_CREAT时才会使用到第三个参数mode：
S_IRWXU 用户的读写执行权限
S_IRUSR 用户的读权限
S_IWUSR 用户的写权限
S_IXUSR 用户的执行权限
S_IRWXG 用户组的读写执行权限
返回值：文件的编号，为-1时，打开文件失败。

读写文件

使用read创建函数

 #include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);

参数列表：
fd:打开文件后的编号
buf：将文件读取到指定的字符数组中
count：可以读取文件的最大长度
返回值：
为0时，读到了到文件的末尾，为-1时，表示文件读取结束。。

使用write写文件操作

 #include <unistd.h>

       ssize_t write(int fd, const void *buf, size_t count);

参数列表：
fd:打开文件后的文件编号
buf:将指定的字符数组中的字符读入文件中
count：可以读取长度，常用来填写read函数的返回值

close关闭文件的函数

#include <unistd.h>

       int close(int fd);

参数：
fd：文件的编号

lseek文件定位函数

 #include <sys/types.h>
       #include <unistd.h>

       off_t lseek(int fd, off_t offset, int whence);

参数列表：
fd：文件编号
offset：文件的位置
whence：
SEEK_SET
SEEK_CUR
SEEK_END

stat获取文件的属性

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
       int stat(const char *path, struct stat *buf);
       int fstat(int fd, struct stat *buf);
       int lstat(const char *path, struct stat *buf);

参数列表：
path：文件的路径
buf：文件信息的结构体
可以使用man手册查看结构体的数据

for example：文件的copy

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>

#define BUFFER_SIZE 100

int main(int argc,char *argv[])
{
    if(argc != 3)
    {
        printf("usage:%s<src_file> <dst_file>\n",argv[0]);
        return 1;
    }   
    
    int src_fd = 0;
    int dst_fd = 0;
    int n = 0;
    char buf[BUFFER_SIZE] = {"\0"};
    char *src_file = argv[1];
    char *dst_file = argv[2];
    char cover_dir = '\0';
    char cover_filename[BUFFER_SIZE] = {'\0'};
    
    if(access(dst_file,F_OK) == 0)
    {
        printf("directorie is exist!!,,Do you want to cover, y or n：");
        scanf("%c",&cover_dir);
        switch(cover_dir)
        {
            case 'y':
            case 'Y':
                {
                    //dst_fd = open(dst_file,O_WRONLY | O_TRUNC,S_IRUSR | S_IWUSR);
                    if((dst_fd = open(dst_file,O_WRONLY | O_TRUNC)) == -1)
                    {
                        perror("open dst error");
                        return -1;
                    }
                }
                break;
            case 'n':
            case 'N':
                {
                    printf("Please resume load of filename:");
                    getchar();
                    scanf("%s",cover_filename);
                    if((dst_fd = open(cover_filename,O_WRONLY | O_TRUNC | O_CREAT,S_IRUSR | S_IWUSR)) == -1)
                    {
                        perror("open dst error\n");
                        return -1;
                    }   
                    break;                  
                }
                break;
            default:
                    printf("Please input again!!!\n");
                    return -1;
        }
    }
    else{
        if((dst_fd = open(dst_file,O_WRONLY | O_TRUNC | O_CREAT,S_IRUSR | S_IWUSR)) == -1)
        {
                            perror("open dst error");
                            return -1;
        }
    }
    if((src_fd = open(src_file,O_RDONLY)) == -1)
    {
        perror("open src error");
        return -1;
    }
    
    while((n = read(src_fd,buf,BUFFER_SIZE)) > 0)
    {
        write(dst_fd,buf,n);
    }
    
    close(src_fd);
    close(dst_fd);
    
    //1.open

    //2.1 read data form src_file
    //2.2 write data to dst_file
    
    //3.close       
    return 0;
}

• 读写函数必须在while中操作，是循环对字符串得到操作。

1.2目录操作

Linux下一切皆文件

mkdir创建目录

 #include <sys/stat.h>
 #include <sys/types.h>
       int mkdir(const char *pathname, mode_t mode);

参数列表：
pathname：目录创建的路径
mode：目录的模式
返回值：为-1时，表示失败，为0时表示成功

rmdir删除目录

  #include <unistd.h>
       int rmdir(const char *pathname);

参数列表：
目录的路径
返回值：
为0时，代表目录删除成功，为-1代表失败。

opendir打开目录

 #include <sys/types.h>
       #include <dirent.h>

       DIR *opendir(const char *name);

参数列表：
name：目录的名称
返回值：返回为NULL时，目录打开失败

readdir读取目录

 #include <dirent.h>
          struct dirent *readdir(DIR *dirp);
          int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result);//进行判断是否读取成功

参数列表：
dirp：文件类型和opendir返回值的类型一致
返回值：返回一个结构体，其中d_name数据类型是文件的名称，

closedir关闭程序

#include <sys/types.h>
#include <dirent.h>
       int closedir(DIR *dirp);

参数列表：
dirp：opendir打开文件的类型
返回值：0是成功，1是失败

#include<stdio.h>
#include<sys/types.h>
#include<dirent.h>
//#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>


int main(int argc ,char *argv[])
{
    if(argc != 2)
    {
        printf("usage:%s <dst_file>",argv[1]);
        return -1;
    }
    
    char *dst_file = argv[1];
    DIR *dirp = NULL;
    struct dirent *dp = NULL;
    struct stat *buf = NULL;

    if((dirp = opendir(dst_file)) == NULL){
        perror("opendir failed!!!");
        return -1;
    }
    while((dp = readdir(dirp)) != NULL){
        if(dp->d_name[0] == '.');
        else
            printf("%s\n",dp->d_name);
    }
     //int stat(const char *path, struct stat *buf);
     int n = stat(dst_file,buf);
     printf("%ld",buf->st_mode);

    closedir(dirp);
    
    return 0;
}

• readdir必须在while中执行，是逐条读取的

多进程编程

进程的创建和调度

getpid/getppid进程ID号

#include <sys/types.h>
       #include <unistd.h>

       pid_t getpid(void);
       pid_t getppid(void);

参数：void
返回值：
分别为当前进程和父进程的进程号

fork复制创建新的进程

#include <unistd.h>
       pid_t fork(void);

参数：void
返回值：为0时代表子进程，>0时为父进程，通常用于区分父子进程的。

exec函数族替换创建新进程

#include <unistd.h>

       extern char **environ;

       int execl(const char *path, const char *arg, ...);
       int execlp(const char *file, const char *arg, ...);
       int execle(const char *path, const char *arg,
                  ..., char * const envp[]);
       int execv(const char *path, char *const argv[]);
       int execvp(const char *file, char *const argv[]);
       int execvpe(const char *file, char *const argv[],
                   char *const envp[]);

参数列表：
path:文件路径
arg：参数列表，其后通常都会跟NULL

• 例子：

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<string.h>
#include<sys/stat.h>
#include<pwd.h>
#include <grp.h>

#define DEBUG_MODE 1

#define COM_MAX_LEN 128

int main(int argc,char *argv[])
{
    pid_t pid = 0;
    char command[COM_MAX_LEN] = {'\0'};
    int status = 0;
    char *delim = " ";
    char *str_command[2];
    struct passwd *pw = NULL;
    struct stat file_stat;
    
    memset(&file_stat, 0, sizeof(file_stat));
    
    while(1)
    {
        // 通过文件所有者ID获取文件所有者名称
        pw = getpwuid(file_stat.st_uid);
        printf("%s>", pw->pw_name);
        
        //printf(">>>>>>>>>");
        //uid_t     st_uid;     /* user ID of owner */

        
        fgets(command,COM_MAX_LEN,stdin);
        command[strlen(command)-1] = '\0';
        
        if(strcmp(command,".exit") == 0)
            return 0;
        
        str_command[0] = strtok(command,delim);
        str_command[1] = strtok(NULL,delim);
        //strcpy(str_command[],p);
    
        if((pid = fork()) == 0)
        {
        
            
            printf("in child peocess :%d\n",getpid());
            //利用exec函数将该子进程的执行指令替换
            execlp(str_command[0],str_command[0],str_command[1],NULL);
            //在path路劲中收索执行ls命令
            //2.在path路劲中搜索执行ls -l /命令
            //execlp("ls","ls","-l",NULL);
            return 0;
            
        }
        //防止僵尸进程的产生
        pid = wait(&status);
#if DEBUG_MODE
        printf("in parent process child %d process exit code: \n",pid);
#endif  
    
    }
    return 0;
}

wait/waitpid等待子进程退出

#include <sys/types.h>
       #include <sys/wait.h>

       pid_t wait(int *status);

       pid_t waitpid(pid_t pid, int *status, int options);

参数：
status：
返回值：返回子进程的ID
作用：放置僵尸进程的产生

信号

一直异步通知机制
常用的信号量有：
SIGINT/SIGQUIT/SIGCLARM/SIGCHLD
信号的三种处理方式：默认处理，忽略，自定义函数

• 注意，信号处理不用做耗时操作

signal/sigaction注册信号处理函数

 #include <signal.h>

       typedef void (*sighandler_t)(int);
       int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);

       sighandler_t signal(int signum, sighandler_t handler);
       void ( *signal(int signum, void (*handler)(int)) ) (int);

参数列表：
signum:信号值
handler：信号处理函数
act：信号处理的一个结构体，里边存放的有信号李处的函数指针

kill/组合键发送信号

 #include <sys/types.h>
       #include <signal.h>

       int kill(pid_t pid, int sig);

参数列表：
pid：进程号
sig：信号
返回值：
发送成功为0；

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>

pid_t pid;

void parent_process_sig_handler(int signo);

void child_process_sig_handler(int signo);

int main(int argc,char *argv[])
{
    
    
    signal(SIGINT,parent_process_sig_handler);
    signal(SIGCHLD,parent_process_sig_handler);
    
    if((pid = fork()) == 0)
    {
        while(1)
        {
        
            signal(SIGINT,SIG_IGN);
            signal(SIGUSR1,child_process_sig_handler);
        
            int client_id = 0;
            
            client_id = rand()%100+1;
            printf("load data %dfrom data center..\n",client_id);
            sleep(1);
            printf("process data %ddown...\n",client_id);
        }
    }
    else if(pid > 0)
    {
        while(1);
    }
    else
    {
    
    }
}

void parent_process_sig_handler(int signo)
{
    switch(signo)
    {
        case SIGCHLD:
        printf("SIGCHLD");
        wait(NULL);
        break;
        case SIGINT:
        kill(pid,SIGUSR1);
        break;
        default:
        break;
    }
}

void child_process_sig_handler(int signo)
{
    if(signo == SIGUSR1)
    {
        printf("..%d\n",getpid());
        exit(0);
    }
}

进程间通信

多线程编程

线程的创建和调度

pthread线程库
pthread_create创建线程

 #include <pthread.h>

       int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);

参数列表：
thread：线程ID的地址
attr：NULL
(*start_routine)(void *)：线程函数指针,返回值也是一个函数指针类型
arg:传递给函数指针的参数

pthread_join等待获取线程的返回值

 #include <pthread.h>

       int pthread_join(pthread_t thread, void **retval);

参数列表：
thread：线程的ID
retval：(void **)线程的返回值

pthread_exit退出线程

#include <pthread.h>

       void pthread_exit(void *retval);

参数列表：线程结束时的返回值(void *)；

pthread_self获取线程自身ID

#include <pthread.h>

       pthread_t pthread_self(void);

参数列表：
void
返回值：线程自身的ID

pthread_equal判断线程是否相等

#include <pthread.h>

       int pthread_equal(pthread_t t1, pthread_t t2);

参数列表：
t1：线程1
t2：线程2
返回值：如果两个线程是相等的，则返回的是非0的数值
否则，为0

pthread_cancel取消指定线程

 #include <pthread.h>

       int pthread_cancel(pthread_t thread);

参数列表：
thread：线程ID
返回值：如果成功返回值为0，失败则返回一个非零的数值

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

struct thread_arg
{
    int thread_no;
    int lower;
    int upper;
};

struct thread_arg argument1,argument2;

void *add_thread_func(void *arg);

int main(int argc,char *argv[])
{
    pthread_t thread_id1;
    pthread_t thread_id2;
    int *psum1 = NULL;
    int *psum2 = NULL;
    
    argument1.thread_no = 1;
    argument1.lower = 1;
    argument1.upper = 500;
    pthread_create(&thread_id1,NULL,add_thread_func,&argument1);
    
    argument2.thread_no = 2;
    argument2.lower = 501;
    argument2.upper = 1000;
    pthread_create(&thread_id2,NULL,add_thread_func,&argument2);
    
    pthread_join(thread_id1,(void **)&psum1);
    pthread_join(thread_id2,(void **)&psum2);
    
    printf("sum = %d\n",*psum1 + *psum2);
    
    free(psum1);
    free(psum2);
    
    return 0;
}

void *add_thread_func(void *arg)
{
     struct thread_arg *p_arg = (struct thread_arg *)arg;
     int i = 0;
     int sum = 0;
     int *psum = (int *)malloc(sizeof(int));
     
     for(i = p_arg->lower;i < p_arg->upper+1;i++)
        sum += i;
     
     //printf("in thread no %d :sum = %ld\n",p_arg->thread_no,sum);
     *psum = sum;
     
     pthread_exit(psum);
}

线程并发要求

同步：进程、线程中部分指令需要按照一定顺序执行
异步：进程、线程的指令执行顺序无序
互斥：对共享的资源操作只能有一个线程或进程
竞争：对有限资源的共享产生的竞争关系
死锁：互相等待资源
饥饿：长时间无法获得资源

线程间通信

• 1，信息交换：使用多个线程都可见的内存区域
• 2，线程互斥锁：保障有同一把锁保护的共享资源被多个线程互相访问

pthread_mutex_t互斥锁

互斥锁的类型

pthread_mutex_init互斥锁初始化
pthread_mutex_lock互斥锁的获取（加锁）
pthread_mutex_unlock互斥锁的释放(解锁)

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

struct thread_arg
{
    int thread_no;
    int lower;
    int upper;
};

struct thread_arg argument1,argument2;

void *add_thread_func(void *arg);

int main(int argc,char *argv[])
{
    pthread_t thread_id1;
    pthread_t thread_id2;
    int *psum1 = NULL;
    int *psum2 = NULL;
    
    argument1.thread_no = 1;
    argument1.lower = 1;
    argument1.upper = 500;
    pthread_create(&thread_id1,NULL,add_thread_func,&argument1);
    
    argument2.thread_no = 2;
    argument2.lower = 501;
    argument2.upper = 1000;
    pthread_create(&thread_id2,NULL,add_thread_func,&argument2);
    
    pthread_join(thread_id1,(void **)&psum1);
    pthread_join(thread_id2,(void **)&psum2);
    
    printf("sum = %d\n",*psum1 + *psum2);
    
    free(psum1);
    free(psum2);
    
    return 0;
}

void *add_thread_func(void *arg)
{
     struct thread_arg *p_arg = (struct thread_arg *)arg;
     int i = 0;
     int sum = 0;
     int *psum = (int *)malloc(sizeof(int));
     
     for(i = p_arg->lower;i < p_arg->upper+1;i++)
        sum += i;
     
     //printf("in thread no %d :sum = %ld\n",p_arg->thread_no,sum);
     *psum = sum;
     
     pthread_exit(psum);
}

• 线程信号量：解决多个线程在使用有限共享资源时的同步问题

sem_t线程信号量

线程信号量的数据类型

sem_init信号量的初始化

#include <semaphore.h>

       int sem_init(sem_t *sem, int pshared, unsigned int value);

参数列表：
sem：信号量的名称地址
pshared：一般为0
value：线程信号量的初始值
返回值：成功为0，失败为-1

sem_wait信号量获取（-1）

 #include <semaphore.h>
       int sem_wait(sem_t *sem);

参数列表：
sem：线程信号量的地址，通常需要加地址符
返回值：成功为0，失败为-1

sem_post信号量的释放（+1）

 #include <semaphore.h>
       int sem_post(sem_t *sem);

参数列表：
sem：线程信号量的地址，通常需要加地址符
返回值：成功为0，失败为-1

sem_destroy信号量的销毁

#include <semaphore.h>
       int sem_destroy(sem_t *sem);

参数列表：
sem：线程信号量的地址，通常需要加地址符
返回值：成功为0，失败为-1

*例子：

#include<stdio.h>
#include<semaphore.h>
#include<pthread.h>
#include<signal.h>
#include<unistd.h>

sem_t sem;

void *thread_func(void *arg);

void sig_handler(int signo);

int main(int argc,char *argv[])
{
    pthread_t thread_id;
    
    //注册信号发送函数
    signal(SIGINT,sig_handler);
    
    //初始化信号量,值为0
    sem_init(&sem,0,0);
    
    pthread_create(&thread_id,NULL,thread_func,NULL);
    
    pthread_join(thread_id,NULL);
    
    printf("main....\n");
    
    //销毁信号量
    sem_destroy(&sem);
    
    return 0;
}

void *thread_func(void *arg)
{
    while(1)
    {
        sem_wait(&sem);
        //信号量减一
        printf("thread func...\n");
        
        sleep(3);
    }
    
    pthread_exit(NULL);
}

void sig_handler(int signo)
{
    if(signo == SIGINT)
    {
        sem_post(&sem);
        //信号量加一
    }
    
    pthread_exit(NULL);
}

---

进程的执行状态：新建、就绪、运行、阻塞、退出
僵尸进程：自己进程退出之后，没有父进程wait
孤儿进程：父进程在子进程之前退出，该子进程称为孤儿进程，进而被init进程收养