UNP 学习笔记 第二十六章

最新推荐文章于 2022-04-02 16:09:05 发布
最新推荐文章于 2022-04-02 16:09:05 发布
阅读量263 收藏
点赞数
分类专栏： unix网络编程总结 文章标签： 多进程 多线程 c语言 服务器 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42254068/article/details/109952175
版权

一.概述

上接第5章,实现完多进程服务器后,开始实现多线程服务器.
多线程服务器最重要的问题就是同步互斥问题.
因此我的多线程服务器的学习步骤为:
	1.熟悉线程间的同步和对资源的互斥访问问题,主要用到互斥锁,信号量和条件变量
	2.线程方面重点API的学习.
	3.复习csapp第10章,
	4.大致翻看http图解这本书,复习html基础知识
	5.结合csapp第11章,实现对http处理的服务器,使得客户可以请求一个http页面.
	6.结合csapp第12章,将服务器改进为多线程.
	7.学习第15章,在上述服务器中加入Unix域协议,并尽可能多的加入其它线程间通信机制
至此多线程web服务器结束,下一步学习各种IO函数,同时实现基于EPOLL的事件驱动服务器

二. 看APUE线程的部分

三. 复习用gdb调试多线程

四.本书重点API的学习

基本线程创建终止等
1.   pthread_create
2.   pthread_join
3.   pthread_self
4.   pthread_detach
5.   pthread_exit
互斥锁
6.   pthread_mutex_lock
7.   pthread_mutex_unlock
条件变量
8.   pthread_cond_wait
9.   pthread_cond_signal
10.  pthread_cond_broadcast

五. 书上例子

使用线程的str_cli函数

整个26.4一节讨论了给线程传参数

  1. 首先是直接把int强制转换为void* <— 图26.3
    –>但是部分系统不支持这种转换
  2. 然后是把int* 强制转换为void* <— 26.4.1
    –>但是存在connfd被覆盖的问题
  3. 然后是每次连接都动态分配connfd <— 图26.4
    –>但是malloc和free是不可重入函数

线程特定数据和随后的例子略过

图26-17 感受并发编程对共享资源的访问问题

图26-18 感受通过加锁解决共享资源的访问问题

26.8节 重点阅读对条件变量内部具有解锁再加锁这一操作的解释

六. 实现具有线程池的多线程服务器

复习CSAPP第10章开始到最后

1.重点API

1. open
2. close
3. stat && fstat && struct stat 
4. S_ISREG && S_ISDIR && S_ISSOCK
5.  dup2
6.

2.实现带缓冲的IO函数

rio.h

//there are robust IO functions.

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

#define MAX_BUFSIZE 8192

typedef struct{
  int   rio_fd;                 //file sockfd which connected to buffer
  int   rio_cnt;                //bytes that hasn't be read
  char* rio_bufptr;             //pointer
  char  rio_buf[MAX_BUFSIZE];   //buffer,store data
}rio_t;

//initializer
void rio_initb(rio_t* rp,int fd)
{
  rp->rio_fd = fd;
  rp->rio_cnt = 0;
  rp->rio_bufptr = rp->rio_buf;
}

static ssize_t rio_read(rio_t* rp,char* buf,size_t n)
{
  while(rp->rio_cnt <= 0)
  {
    rp->rio_cnt = read(rp->rio_fd,rp->rio_buf,sizeof(rp->rio_buf));
    if(rp->rio_cnt < 0)
    {
      if(errno != -1)
        return -1;
    }else if(rp->rio_cnt == 0){
      return 0;
    }else{
      rp->rio_bufptr = rp->rio_buf;
    }
  }
  int cnt = (size_t)rp->rio_cnt < n ? (int)rp->rio_cnt : n;
  memcpy(buf,rp->rio_bufptr,cnt);
  rp->rio_bufptr += cnt;
  rp->rio_cnt -= cnt;
  return cnt;
}

ssize_t rio_readnb(rio_t* rp,void* buf,size_t n)
{
  size_t nleft = n;
  ssize_t nread;
  char* bufp = (char*) buf;
  while(nleft)
  {
    if((nread = rio_read(rp,bufp,nleft)) < 0)
      return -1;
    else if(nread == 0)
      break;
    nleft -= nread;
    bufp += nread;
  }
  return n - nleft;
}

int rio_readlineb(rio_t* rp,void* buf,size_t maxlen)
{
  int     n,rc;
  char    c;
  char* bufp = (char*)buf;
  for(n = 1;(size_t) n < maxlen; ++n)
  {
    if((rc = rio_read(rp,&c,1)) == 1)
    {
      *bufp++ = c;
      if(c == '\n')
      {
        n++;
        break;
      }
    }else if(rc == 0){
      if(n == 1)
        return 0;
      else
        break;
    }else
      return -1;
  }
  *bufp = 0;
  return n - 1;
}

测试代码

从text.txt文件里按行读取每一行,并且输出到终端上

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include "rio.h"
#include <fcntl.h>

#define MAXLINE 8192

int main()
{
  int fd = open("text.txt",O_RDONLY,0);
  rio_t rio;
  char sendline[MAXLINE];

  rio_initb(&rio,fd);
  
  while((rio_readlineb(&rio,sendline,sizeof(sendline)) != 0))
  {
    write(STDOUT_FILENO,sendline,strlen(sendline));
  }
  return 0;
}

执行结果

在这里插入图片描述

3.读取文件元数据

查询和处理一个文件的st_mode位要会

4. IO重定向

先略微看看共享文件这一小节

测试代码

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

int main()
{
  int fd = open("text.txt",O_RDONLY,0);
  dup2(fd,STDIN_FILENO);
  
  char buf[8192];
  
  while(fgets(buf,sizeof(buf),stdin))//对STDIN_FILENO重定向后,操作stdin也是操作fd了
    fputs(buf,stdout);

  return 0;
}

在这里插入图片描述

5.http图解看一遍,重点内容已标出.

6.学习CSAPP第9章,第11章的 TINY WEB

tiny.h

#include <sys/socket.h>
#include <sys/wait.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netdb.h>

#define MAXLINE 8192

typedef struct{
  int   rio_fd;
  int   rio_cnt;
  char* rio_bufptr;
  char  rio_buf[MAXLINE];
}rio_t;

void rio_readinitb(rio_t* rp,int fd)
{
  rp->rio_fd = fd;
  rp->rio_cnt = 0;
  rp->rio_bufptr = rp->rio_buf;
}

ssize_t rio_read(rio_t* rp,char* buf,size_t nbytes)
{
  size_t cnt;
  while(rp->rio_cnt <= 0)
  {
    rp->rio_cnt = read(rp->rio_fd,rp->rio_buf,MAXLINE);
    if(rp->rio_cnt < 0)
    {
      if(errno != EINTR)
        return -1;
    }
    else if(rp->rio_cnt == 0)
      return 0;
    else
      rp->rio_bufptr = rp->rio_buf;
  }
  cnt = (size_t)rp->rio_cnt < nbytes ? (size_t)rp->rio_cnt : nbytes;
  memcpy(buf,rp->rio_bufptr,cnt);
  rp->rio_bufptr += cnt;
  rp->rio_cnt -= cnt;
  return cnt;
}

ssize_t rio_readlineb(rio_t* rp,char* buf,size_t maxlen)
{
  int     n,rc;
  char* bufp = buf, c;
  for(n = 1; (size_t)n < maxlen; ++n)
  {
    if((rc = rio_read(rp,&c,1)) == 1)
    {
      *bufp++ = c;
      if(c == '\n')
      {
        n++;
        break;
      }
    }else if(rc == 0){
      if(n == 1)
        return 0;
      else
        break;
    }else
      return -1;
  }
  *bufp = '\0';
  return n - 1;
}

ssize_t rio_writen(int fd,const char* buf,size_t nbytes)
{
  ssize_t nwritten;
  const char* p = buf;
  size_t nleft = nbytes;
  while(nleft > 0)
  {
    if((nwritten = write(fd,p,nleft)) <= 0)
    {
      if(errno == EINTR)
        nwritten = 0;
      else
        return -1;
    }
    nleft -= nwritten;
    p += nwritten;
  }
  return nbytes;
}

int open_client(const char* host,const char* port)
{
  int fd;
  struct addrinfo hints, *listp, *p;
  bzero(&hints,sizeof(hints));
  hints.ai_family = AF_INET;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;
  
  getaddrinfo(host,port,&hints,&listp);
  for(p = listp; p; p = p->ai_next)
  {
    fd = socket(p->ai_family,p->ai_socktype,p->ai_protocol);
    if(fd < 0)
      continue;
    if((connect(fd,p->ai_addr,p->ai_addrlen)) == 0)
      break;
    close(fd);
  }
  freeaddrinfo(listp);
  if(!p)
    return -1;
  return fd;
}

int open_server(const char* host,const char* port)
{
  const int on = 1;
  int sockfd;
  struct addrinfo hints,*listp,*p;
  bzero(&hints,sizeof(hints));
  hints.ai_family = AF_UNSPEC;
  hints.ai_flags  = AI_PASSIVE;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;

  getaddrinfo(host,port,&hints,&listp);

  for(p = listp; p; p = p->ai_next)
  {
    sockfd = socket(p->ai_family,p->ai_socktype,p->ai_protocol);
    if(sockfd < 0)
      continue;
    setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,(const void*)&on,sizeof(on));
    if((bind(sockfd,p->ai_addr,p->ai_addrlen)) == 0)
      break;
    close(sockfd);
  }
  freeaddrinfo(listp);
  if(!p)
    return -1;
  if(listen(sockfd,100) < 0){ //backlog == 100
    close(sockfd);
    return -1;
  }
  return sockfd;
}

serv.h

#include "tiny.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>

extern char** environ;

void doit(int connfd);
void read_requesthdrs(rio_t* rp,char* buf);
int parse_uri(char* uri,char* filename,char* cgiargs);
void get_filetype(char* filename,char* filetype);
void serve_static(int fd,char* filename,int filesize);
void serve_dynamic(int fd,char* filename,char* cgiargs);
void client_error(int fd,char* errnum,char* shortmsg,char* longmsg,char* cause);

void doit(int fd)
{
  char buf[MAXLINE];
  char filename[MAXLINE],cgiargs[MAXLINE];
  char uri[MAXLINE],methods[MAXLINE],version[MAXLINE]; 
  int is_static;
  struct stat st;
  rio_t rio;

  rio_readinitb(&rio,fd);
  rio_readlineb(&rio,buf,MAXLINE);
  
  printf("Request headers:\n");
  printf("%s",buf);

  sscanf(buf,"%s %s %s",methods,uri,version);

  if((strcasecmp(methods,"GET")))
  {
    client_error(fd,"400"," error","TinyWeb only support 'Get'",NULL);
    return;
  }
  
  read_requesthdrs(&rio,buf);
  printf("Headers:\n");
  printf("%s",buf);

  is_static = parse_uri(uri,filename,cgiargs);

  if(stat(filename,&st) < 0)
  {
    client_error(fd,"400","Invalid file","You request for a invalid file",NULL);
    return;
  }

  if(is_static)
  {
    if(!(S_ISREG(st.st_mode) ) || !(S_IRUSR & st.st_mode))
    {
      client_error(fd,"400","Permission denied","You don't have permission\n",NULL);
      return;
    }
    serve_static(fd,filename,st.st_size);
  }else{
    if(!(S_ISREG(st.st_mode) ) || !(S_IXUSR & st.st_mode))
    {
      client_error(fd,"400","Permission denied","You don't have permission\n",NULL);
      return;
    }
    serve_dynamic(fd,filename,cgiargs);
  }
}

void read_requesthdrs(rio_t* rp,char* buf)
{
  char tmp[MAXLINE];
  rio_readlineb(rp,tmp,MAXLINE);
  while(strcmp(tmp,"\r\n"))
  {
    sprintf(buf,"%s",tmp);
    rio_readlineb(rp,tmp,MAXLINE);
  }
  return;
}

int parse_uri(char* uri,char* filename,char* cgiargs)
{
  char *ptr;
  if(!(strstr(uri,"cgi-bin")))//static
  {
    strcpy(filename,"");
    strcat(filename,".");
    strcat(filename,uri);

    if(uri[strlen(uri) - 1] == '/')
      strcat(filename,"home.html");
    return 1;
  }else{
    ptr = index(uri,'?');
    if(ptr){
      strcpy(cgiargs,"");
      strcat(cgiargs,ptr + 1);
      *ptr = '\0';
    }else{
      strcpy(cgiargs,"");
    }
    strcpy(filename,".");
    strcat(filename,uri);
    return 0;
  }

}

void get_filetype(char* filename, char* filetype)
{
  if(strstr(filename,".html"))
    strcpy(filetype,"text/html");
  else if(strstr(filename,".jpg"))
    strcpy(filetype,"image/jpeg");
  else if(strstr(filename,".png"))
    strcpy(filetype,"image/png");
  else if(strstr(filename,".gif"))
    strcpy(filetype,"image/gif");
  else
    strcpy(filetype,"text/plain");
}

void serve_static(int fd,char* filename,int filesize)
{
  char buf[MAXLINE];
  char filetype[MAXLINE];
  get_filetype(filename,filetype);
  
  sprintf(buf,"HTTP/1.0 200 OK\r\n");
  sprintf(buf,"%sServer: TinyWeb\r\n",buf);
  sprintf(buf,"%sConnection: close\r\n",buf);
  sprintf(buf,"%sContent-type: %s\r\n",buf,filetype);
  sprintf(buf,"%sContent-length: %d\r\n\r\n",buf,filesize);
  rio_writen(fd,buf,strlen(buf));
  printf("Response headers:\n");
  printf("%s",buf);

  int srcfd = open(filename,O_RDONLY,0);
  char* srcp =(char*) mmap(NULL,filesize,PROT_READ,MAP_PRIVATE,srcfd,0);
  rio_writen(fd,srcp,filesize);
  close(srcfd);
  munmap(srcp,filesize);
}


void serve_dynamic(int fd,char* filename,char* cgiargs)
{
  char *emptylist[] = {NULL},buf[MAXLINE];

  sprintf(buf,"HTTP/1.0 200 OK\r\n");
  sprintf(buf,"%sServer: Tiny Web Server\r\n",buf);
  rio_writen(fd,buf,strlen(buf));

  if(fork() == 0)
  {
    setenv("QUERY_STRING",cgiargs,1);
    dup2(fd,STDOUT_FILENO);
    execve(filename,emptylist,environ);
  }
  wait(NULL);
}


void client_error(int fd,char* errnum,char* shortmsg,char* longmsg,char* cause)
{
  char buf[MAXLINE],body[MAXLINE];
  sprintf(body,"<html><title>TinyWeb Error</title>");
  sprintf(body,"%s<body bgcolor=""ffffff"">\r\n",body);
  sprintf(body,"%s%s: %s\r\n",body,errnum,shortmsg);
  sprintf(body,"%s<p>%s: %s\r\n",body,longmsg,cause);
  sprintf(body,"%s<hr><em>TinyWeb</em>\r\n",body);

  sprintf(buf,"HTTP/1.1 %s %s\r\n",errnum,shortmsg);
  sprintf(buf,"%sContent-type: text/html\r\n",buf);
  sprintf(buf,"%sContent-length: %d\r\n\r\n",buf,(int)strlen(body));
  
  rio_writen(fd,buf,strlen(buf));
  rio_writen(fd,body,strlen(body));

}

serv.c

#include "serv.h"

int
main(int argc, char** argv)
{
  if(argc != 2){
    fprintf(stderr,"Please enter port\n");
    exit(0);
  }
  int listenfd = open_server(NULL,argv[1]);
  //ipv4
  struct sockaddr_in sin;
  socklen_t len;
  char host[MAXLINE];
  int connfd;

  while(1)
  {
    len = sizeof(sin);
    connfd = accept(listenfd,(struct sockaddr*) &sin,&len);

    getsockname(connfd,(struct sockaddr* )&sin,&len);
    inet_ntop(AF_INET,(const void*)&sin.sin_addr,host,MAXLINE);
    printf("%s:%d has connected!\n",host,sin.sin_port);

    doit(connfd);
    close(connfd);
  }
  return 0;
}

效果展示:请求首页

在这里插入图片描述
在这里插入图片描述

效果展示: 请求图片

在这里插入图片描述
在这里插入图片描述

总结

1. 毫无错误处理
2. 毫无边界处理
3. 这是一个迭代服务器,一次只能处理一个客户的请求.
4. 接下来,对其改进.

7.改进为多线程服务器

仅对以上代码做出了一点修改:

//serv.h中做出以下修改,即,将doit函数的返回值和参数更改为线程例程的格式
void* doit(void* args)
{
  char buf[MAXLINE];
  char filename[MAXLINE],cgiargs[MAXLINE];
  char uri[MAXLINE],methods[MAXLINE],version[MAXLINE]; 
  int is_static;
  struct stat st;
  rio_t rio;
  int fd = *(int*)args;

 

//serv.c中做出以下修改.现在每当有新连接到达时,便会使用新的线程去处理.
  while(1)
  {
    len = sizeof(sin);
    connfd = accept(listenfd,(struct sockaddr*) &sin,&len);

    getsockname(connfd,(struct sockaddr* )&sin,&len);
    inet_ntop(AF_INET,(const void*)&sin.sin_addr,host,MAXLINE);
    printf("%s:%d has connected!\n",host,sin.sin_port);

    pthread_create(&tid,NULL,doit,&connfd);
  }

如UNP和csapp都提到的,这样存在着很严重的同步问题.
尝试在下一章进行解决.

猪二哥
关注
专栏目录
《UNP》的零碎知识点总结
qq_35539135的博客
03-01 456
。套接字工作在应用层和传输层之间，套接字之上为用户进程，套接字之下4层是构成操作系统内核的一部分，上三层大部分关注网络应用的细节，下四层大部分关注通信细节 用于发现网络细节的两个基本命令，netstat和ipconfig 分组过滤器：用来截获和过滤一个被置为混杂模式的网络接口的分组 应用进程往一个UDP套接字写入一个消息，该消息随后被封装成一个UDP数据报，进而又被封装成一个IP...
UNP 学习笔记(一)：简介
amoscykl的博客
05-02 5213
简介概述客户与服务器之间是通过某个网络协议通信的。焦点是TCP/IP协议族，也称为网际协议族。 同一网络应用的客户和服务器无需处于同一个服务器，而这两个局域网是使用路由器连接到广域网(WAN)的。路由器是广域网的架构设备。当今最大的广域网是因特网。 一个简单的时间获取服务器程序/* 一个简单的时间获取服务器程序 */ #include "unp.h"                        ...
UNP 学习笔记 第五章
weixin_42254068的博客
11-21 287
一. 复习所有的ANSI C IO函数 1. printf 和 scanf .各种格式都要复习到 2. fprintf 和 fscanf 3. sscanf 和 sprintf ,snprintf 4. fgets 和 fputs 5. gets 和 puts 6. vsnprintf 可变参数列表 7. putc 和 getc 8. putchar 和 getchar ...
拜读UNP前两部分
windyear
03-06 1627
前言 利用国庆黄金周的假期，粗略地看了UNIX网络编程这边关于网络编程的经典书籍。主要当做是复习了一下计算机网络的知识，还有了解了一些基本的套接字编程，包含TCP、UDP和SCTP三种不同的传输层协议。在这里写一篇总结，当做是知识的整理。 第一部分：简介和TCP/IP 第一章： 简介 大三下学期学过计算机网络这么课，当时学的糊里糊涂，只了解到计算机网络是分层的，然后每层里面都...
重读UNP（UNIX网络编程）13章到31章笔记整理（结合TLPI和APUE两书的笔记整理）
nosix的博客
07-28 957
因为UNP第三部分（第三版13-31章）的内容结合APUE（UNIX环境高级编程）和TLPI（The Linux Programming Interface）来看才能比较清晰，所以笔记整理会穿插很多这两本书的内容 13章 13.4节：自定义一个daemon_init函数，涉及到知识点为“如何创建一个daemon（守护进程）”，实现步骤如下： fork之后杀掉父进程（此时子进程被init收养）这是为
UNP（卷2：进程间通信）—— 第一章：简介
Joe's Blog
06-13 571
IPC是进程间通信（interprocess communication）的简称。 消息传递（message passing）： 管道（pipe），命名管道（named pipe）（FIFO）System V消息队列（System V message queue）Posix消息队列远程过程调用（Remote Procedure Call， RPC）：从一个系统上某个程序调用另一
UNP学习笔记讲义
04-29
Linux网络编程修炼指南内功心法，即通过学习UNP（Unix Network Programming）来深入理解Linux下的网络编程技术。网络协议基础部分是学习Linux网络编程的前置知识，它主要包括ISO/OSI七层模型的理解、网络协议的概念...
UNIX网络编程(UNP) 第三章学习笔记
404lz保留地
11-21 221
首先我们需要了解套接字地址结构到底长啥样，我们可以在<netinet/in.h>中找到下面的结构 /* * Internet address (a structure for historical reasons) */ struct in_addr { in_addr_t s_addr; // 32位的IPV4地址，一般实现方式是uint3...
UNP笔记：第三章
Owen Wei的博客
12-30 156
UNIX 网络编程 卷1：套接字联网API 套接字编程简介 1 套接字地址结构 对于一个套接字描述符，需要将它绑定到具体的套接字上，而不同协议的套接字具有不同的结构，它们都以sockaddr_开头，并附加一个后缀用来表示具体的套接字类型。 IPv4的套接字结构 IPv4套接字定义在<netinet/in.h>头文件中，显然对应的套接字名称为sockaddr_in。 注：in是Internet的缩写，而结构中的sin_即为sockaddr_in的缩写。 struct in_addr
UNIX网络编程(UNP) 第五章学习笔记
404lz保留地
11-23 286
在本章中，我们将完成一个可以回射的服务器和客户端，并且我们需要理解在每一个环节可能出现什么问题，并且加以预防 代码（带注释） // server #include "../unp.h" int main(int argc, char **argv) { int listenfd,connfd; pid_t child_pid; socklen_t clilen; s...
Linux系统编程之进程
qq_51302626的博客
10-04 453
Linux系统编程之进程 （一）进程的创建 通过一个例子来对进程创建fork函数进行理解 #include<stdio.h> #include<unistd.h> #include<sys/types.h> int main() { pid_t pid; pid_t pid2; pid = getpid(); printf("Before fork:%d\n",pid); fork();
linux进程管理
九层台
04-03 219
创建进程 fork和vfork函数。 二话不说 上栗子。 #include&lt;stdio.h&gt; #include&lt;unistd.h&gt; #include&lt;sys/types.h&gt; int gvar=2; int main(void) { pid_t pid; int var=5; printf("process id:%ld\n",(l...
Linux signal 中断 waitpid 系统调用
sinat_33822516的博客
10-14 433
代码文件test.c #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <errno.h> #include <sys/wait.h> #include <signal.h> void handler(int signo){ printf("i receive a sig,sig number is %d\n",signo); } in
进程间的五种通信（linux系统编程）
weixin_44234294的博客
07-26 397
参考：https://blog.csdn.net/wh_sjc/article/details/70283843 一、管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 特点： 它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。 它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。 它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。 原型 1 #incl
fork()问题详解
行而不辍，未来可期 - King
05-08 6310
最近在看linux编程方面的书，然后也在网上查阅相关的资料发现了一个关于fork()的几个题，在这里记录一下！ #include "sys/types.h" #include "unistd.h" #include pit_t fork(void ); fork()函数调用成功，返回两个值； 父进程：返回子进程的PID； 子进程：返回0； 出错：返回-1、、、、
【Linux】第四篇：进程控制
qq_43041053的博客
04-02 1596
目录1.程序地址空间测试父子进程的地址空间虚拟进程地址空间虚拟地址的由来mm_struct页表2.进程创建fork函数再探fork的返回值写时拷贝fork 的用处fork调用失败3.进程终止进程的退出场景进程常见退出方法exit 函数_exit 函数4.进程等待为何需要等待进程如何进程等待waitwaitpid获取 statusoption：WNOHANG总结5.进程替换替换原理替换函数6.自制简易 shell 1.程序地址空间 程序是由若干个逻辑分段组成的，如可由代码分段、数据分段、栈段、堆段组成。
UNP 学习笔记 第十一章
weixin_42254068的博客
11-20 163
一.
waitpid函数的使用
开始淡漠的博客
06-15 1571
waitpid函数是暂时停止当前进程，直到有信号来或者子进程结束，接收子进程的结束状态值 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;sys/types.h&gt; #include&lt;unistd.h&gt; #include&lt;sys/wait.h&gt; int main() {     int sta...
UNIX网络编程的unp.h
最新发布
07-27
unp.h是该书中提供的一个头文件，它包含了一些与网络编程相关的函数、结构体和常量的声明。这个头文件提供了一些方便的宏定义和函数原型，可以帮助开发者更方便地进行网络编程。 unp.h头文件中包含了很多内容，比如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值