Linux网络：网络套接字-TCP回显服务器——多进程/线程池(生产者消费者模型)

最新推荐文章于 2024-09-10 10:54:43 发布
最新推荐文章于 2024-09-10 10:54:43 发布
阅读量515 收藏 4
点赞数 4
分类专栏： # Linux网络编程 文章标签： 服务器 linux 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61088872/article/details/142061773
版权

1.多进程版本

这里选择创建子进程，让子进程再创建子进程。父进程等待子进程，子进程的子进程处理业务逻辑。因为子进程是直接退出，子进程的子进程变成孤儿进程被系统管理，所以父进程在等待的时候不是阻塞等待的，所以可以处理多条链接请求。或者可以忽略SIGCHID信号让子进程不需要等待。

服务端
pragma once 

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<fcntl.h>
#include<signal.h>
#include<sys/wait.h>

#define DEF_PORT 8081

class TcpSever
{
  private:
    int port;
    int listen_sock;//监听套接字
  public: 
    TcpSever(int _port=DEF_PORT):port(_port),listen_sock(-1)
    {}

    void InitSever()
    {
      listen_sock=socket(AF_INET,SOCK_STREAM,0);//IPV4流式套接
      if(listen_sock<0){
        std::cerr<<"监听套接字创建失败"<<std::endl;
        exit(-1);
      }
      //绑定
      struct sockaddr_in local;
      memset(&local,'\0',sizeof(local));//初始化结构体
      local.sin_family=AF_INET;
      local.sin_port=htons(port);//主机转网络
      local.sin_addr.s_addr=INADDR_ANY;//随机绑定服务器ip
      if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0){
        std::cerr<<"绑定失败"<<std::endl;
        exit(-2);
      }
      //建立链接
#define BACK_LOG 5
      if(listen(listen_sock,BACK_LOG)<0){
        std::cerr<<"链接失败"<<std::endl;
        exit(-3);
      }
    }

    //获取链接
    void Loop()
    {
      //获取客户端信息
      struct sockaddr_in client;
      //signal(SIGCHID,hander);//hander是信号捕捉方法
      while(true)
      {
        socklen_t len=sizeof(client);
        //获取新链接
        int sock=accept(listen_sock,(struct sockaddr*)&client,&len);
        if(sock<0){
          std::cerr<<"接受链接失败"<<std::endl;
          continue;//继续接受其他链接请求
        }
        //多进程处理多个客户端
        pid_t id=fork();
        if(id==0)//子进程
        {
          //子进程,与子进程的子进程不关心listen_sock
          close(listen_sock);
          if(fork()>0)
          {
            exit(0);//子进程直接退出后子进程的子进程变为孤儿进程被守护进程接管，不用等待了
          }
          //子进程的子进程,处理业务
          std::cout<<"获取新连接成功! ip["<<inet_ntoa(client.sin_addr)<<"] port["<<ntohs(client.sin_port)<<"]"<<std::endl;//整数ip转为字符ip形式,网络字节端口转化为本地端口
           //开始服务
          std::string CIp=inet_ntoa(client.sin_addr);
          int CPort=ntohs(client.sin_port);
          Sever(sock,CIp,CPort);
          exit(0);
        }
        //不能使用阻塞等待，可以使用信号机制忽略SIGCHID信号，或者使用两次fork函数
        close(sock);//父进程不关心客户端的链接请求，请求交给子进程做。
        waitpid(id,nullptr,0);//不会阻塞，因为id进程创建完子进程会立即退出，所以不会阻塞。
      }
    }

    void Sever(int sock,std::string&ip,int port)
    {
      char buff[1024];
      while(true)
      {
        memset(buff,0,sizeof(buff));
        ssize_t ReadSize=read(sock,buff,sizeof(buff)-1);
        if(ReadSize>0){
          buff[ReadSize]='\0';//添加字符串结束标志
          std::cout<<"Client["<<ip<<"-port-"<<port<<"]# "<<buff<<std::endl;
          write(sock,buff,ReadSize);//向客户端写入数据
        }
        else if(ReadSize==0){//对端关闭链接
          std::cout<<"Client["<<ip<<"-port-"<<port<<"]# 关闭"<<std::endl;
          break;
        }
        else{
          std::cerr<<sock<<"读取错误"<<std::endl;
          break;
        }
      }
      std::cout<<"服务终止"<<std::endl;
    }
    ~TcpSever(){
      if(listen_sock>=0){
        close(listen_sock);
      }
    }
};
启动服务端 
#include"Tcp_Sever.h"

// Tcp_Sever +port

void User(char*name)
{
  std::cout<<name<<" + port"<<std::endl;
}

int main(int argc,char*argv[])
{
  if(argc!=2){
    User(argv[0]);
    exit(-1);
  }
  TcpSever*Sever=new TcpSever(atoi(argv[1]));//将字符串形式的端口号转化为整数形式
  Sever->InitSever();
  Sever->Loop();
  return 0;
}
客户端 
#pragma once

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string>
#include<string.h>

class TcpClient
{
  private:
    std::string sev_ip;//服务器ip
    int sev_port;
    int sock;
  public:
    TcpClient(std::string _ip,int _sev_port):sev_ip(_ip),sev_port(_sev_port),sock(-1)
    {}

    void InitClient()
    {
      sock=socket(AF_INET,SOCK_STREAM,0);
      if(sock<0){
        std::cerr<<"创建套接字失败"<<std::endl;
        exit(-1);
      }
      //客户端不需要绑定监听
    }

    //启动客户端
    void Start()
    {
      //向服务器发送链接
      //填充服务器信息
      struct sockaddr_in sever;
      memset(&sever,0,sizeof(sever));
      sever.sin_family=AF_INET;
      sever.sin_port=htons(sev_port);//服务器开放的端口
      sever.sin_addr.s_addr=inet_addr(sev_ip.c_str());//服务器的ip地址

      if(connect(sock,(struct sockaddr*)&sever,sizeof(sever))==0){
        //与服务器交互
        std::cout<<"发送交互请求成功"<<std::endl;
        Request(sock);
      }
      else{
        std::cerr<<"交互失败"<<std::endl;
      }
    }

    void Request(int Sock)
    {
      std::string meg;
      while(true)
      {
        std::cout<<"输入信息#";
        std::cin>>meg;
        char buff[1024];
        write(Sock,meg.c_str(),meg.size());
        //读取服务器发送的消息
        ssize_t ReadSize=read(sock,buff,sizeof(buff)-1);
        if(ReadSize>0){
          buff[ReadSize]='\0';
        }
        std::cout<<"Sever#"<<buff<<std::endl;
      }
    }
    
    ~TcpClient()
    {
      if(sock>=0){
        close(sock);
      }
    }
};
启动客户端 
#include"Tcp_Client.h"

// ./Tcp_Client +ip +port

void User(char*name)
{
  std::cout<<name<<" + sever_ip + sever_port"<<std::endl;
}

int main(int argc,char*argv[])
{
  if(argc!=3){
    User(argv[0]);
    exit(-1);
  }

  TcpClient*Client=new TcpClient(argv[1],atoi(argv[2]));
  Client->InitClient();

  Client->Start();
  return 0;
}

2.多线程版本

注意：在类内部的成员函数，调用类内非静态成员函数时会自动带this指针。而线程执行的函数要求void* Hander(void*)类型，所以线程执行函数要用static修饰。

服务端
#pragma once 

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<fcntl.h>
#include<signal.h>
#include<sys/wait.h>
#include<pthread.h>

#define DEF_PORT 8081

//通信结构体
class Pragram{
  public:
    int sock;
    std::string ip;
    int port;
    
    Pragram(int _sock,std::string _ip,int _port)
      :sock(_sock),ip(_ip),port(_port)
    {}
};

class TcpSever
{
  private:
    int port;
    int listen_sock;//监听套接字
  public: 
    TcpSever(int _port=DEF_PORT):port(_port),listen_sock(-1)
    {}

    void InitSever()
    {
      listen_sock=socket(AF_INET,SOCK_STREAM,0);//IPV4流式套接
      if(listen_sock<0){
        std::cerr<<"监听套接字创建失败"<<std::endl;
        exit(-1);
      }
      //绑定
      struct sockaddr_in local;
      memset(&local,'\0',sizeof(local));//初始化结构体
      local.sin_family=AF_INET;
      local.sin_port=htons(port);//主机转网络
      local.sin_addr.s_addr=INADDR_ANY;//随机绑定服务器ip
      if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0){
        std::cerr<<"绑定失败"<<std::endl;
        exit(-2);
      }
      //建立链接
#define BACK_LOG 5
      if(listen(listen_sock,BACK_LOG)<0){
        std::cerr<<"链接失败"<<std::endl;
        exit(-3);
      }
      std::cout<<"服务启动成功"<<std::endl;
    }

    //获取链接
    void Loop()
    {
      //获取客户端信息
      struct sockaddr_in client;
      //signal(SIGCHID,hander);//hander是信号捕捉方法
      while(true)
      {
        socklen_t len=sizeof(client);
        //获取新链接
        int sock=accept(listen_sock,(struct sockaddr*)&client,&len);
        if(sock<0){
          std::cerr<<"接受链接失败"<<std::endl;
          continue;//继续接受其他链接请求
        }
        pthread_t tid;

        std::string ip=inet_ntoa(client.sin_addr);
        int port=ntohs(client.sin_port);
        Pragram*msg=new Pragram(sock,ip,port);
        pthread_create(&tid,nullptr,HanderQuest,msg);
      }
    }
  private:
    static void* HanderQuest(void*arg)
    {
      Pragram*msg=(Pragram*)arg;
      pthread_detach(pthread_self());//线程分离
      std::cout<<"获取新连接成功"<<"[ ip:"<<msg->ip<<" port:"<<msg->port<<" ]"<<std::endl;
      Sever(msg->sock,msg->ip,msg->port);
      close(msg->sock);
      delete msg;
      return nullptr;
    }

    static void Sever(int sock,std::string&ip,int port)
    {
      char buff[1024];
      while(true)
      {
        memset(buff,0,sizeof(buff));
        ssize_t ReadSize=read(sock,buff,sizeof(buff)-1);
        if(ReadSize>0){
          buff[ReadSize]='\0';//添加字符串结束标志
          std::cout<<"Client["<<ip<<"-port-"<<port<<"]# "<<buff<<std::endl;
          write(sock,buff,ReadSize);//向客户端写入数据
        }
        else if(ReadSize==0){//对端关闭链接
          std::cout<<"Client["<<ip<<"-port-"<<port<<"]# 关闭"<<std::endl;
          break;
        }
        else{
          std::cerr<<sock<<"读取错误"<<std::endl;
          break;
        }
      }
      std::cout<<"服务终止"<<std::endl;
    }
    ~TcpSever(){
      if(listen_sock>=0){
        close(listen_sock);
      }
    }
};

客户端代码部分不变。

3.模板线程池版本

线程池代码：

PthreadPool.h

#pragma once 

#include<iostream>
#include<pthread.h>
#include<queue>

#define NUM 5

template<typename Task>
class ThreadPool
{
  private:
    std::queue<Task> _task_queue;//临界资源
    pthread_mutex_t _lock;
    int _thread_num;
    pthread_cond_t _cond;
  public:
   ThreadPool(int Num=NUM):_thread_num(Num){
     pthread_mutex_init(&_lock,nullptr);
     pthread_cond_init(&_cond,nullptr);
   }

   bool IsEmpty(){return _task_queue.empty();}

   static void*Routine(void*arg)//静态函数无隐含的this指针
   {
     pthread_detach(pthread_self());
     ThreadPool<Task>*self=(ThreadPool<Task>*)arg;
     while(true)
     {
       pthread_mutex_lock(&(self->_lock));
       while(self->IsEmpty())//循环检测临界资源是否就绪
       {
         //休眠
         pthread_cond_wait(&(self->_cond),&(self->_lock));
       }
       //任务队列有任务
       Task t;
       self->Pop(t);
       pthread_mutex_unlock(&(self->_lock));
       //解锁后处理任务
       t.Run();
     }
   }

   void Push(const Task&in)//外部添加任务
   {
     pthread_mutex_lock(&_lock);
     _task_queue.push(in);
     //唤醒一个线程
     pthread_cond_signal(&_cond);
     pthread_mutex_unlock(&_lock);
   }

   void Pop(Task&out)//线程获取任务
   {
     out=_task_queue.front();
     _task_queue.pop();
   }

   ~ThreadPool(){
     pthread_mutex_destroy(&_lock);
     pthread_cond_destroy(&_cond);
   }

   void InitThreadPool()
   {
     pthread_t tid;
     for(int i=0;i<_thread_num;i++)
     {
       //为了避免传参时C++传this指针，在线程执行方法上带static。
       //传参数时将this指针传到线程执行方法上。 
       pthread_create(&tid,nullptr,Routine,this);
     }
     
   }
};
设计任务Task.h 

 

#pragma once 

#include<iostream>
#include<string>
#include<unistd.h>
#include<string.h>

struct Hander{
  void operator()(int sock,std::string&ip,int port)
  {
    char buff[1024];
    while(true)
    {
       memset(buff,0,sizeof(buff));
       ssize_t ReadSize=read(sock,buff,sizeof(buff)-1);
       if(ReadSize>0){
         buff[ReadSize]='\0';//添加字符串结束标志
         std::cout<<"Client["<<ip<<"-port-"<<port<<"]# "<<buff<<std::endl;
         write(sock,buff,ReadSize);//向客户端写入数据
       }
       else if(ReadSize==0){//对端关闭链接
         std::cout<<"Client["<<ip<<"-port-"<<port<<"]# 关闭"<<std::endl;
         break;
       }
       else{
         std::cerr<<sock<<"读取错误"<<std::endl;
         break;
      }
    }
    std::cout<<"服务终止"<<std::endl;
    close(sock);
  }
};

class Task{
  private:
    int sock;
    std::string ip;
    int port;
    Hander condut;//仿函数
  public:
    Task()=default;
    Task(int _sock,std::string _ip,int _port)
      :sock(_sock),ip(_ip),port(_port)
    {}

    void Run(){
      condut(sock,ip,port);
    }

};
服务端代码 
#pragma once 

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<fcntl.h>
#include<signal.h>
#include<sys/wait.h>
#include<pthread.h>

#include"ThreadPool.h"
#include"Task.h"

#define DEF_PORT 8081

//通信结构体
class Pragram{
  public:
    int sock;
    std::string ip;
    int port;
    
    Pragram(int _sock,std::string _ip,int _port)
      :sock(_sock),ip(_ip),port(_port)
    {}
};

class TcpSever
{
  private:
    int port;
    int listen_sock;//监听套接字
    ThreadPool<Task>*Pool;
  public: 
    TcpSever(int _port=DEF_PORT):port(_port),listen_sock(-1),Pool(nullptr)
    {}

    void InitSever()
    {
      listen_sock=socket(AF_INET,SOCK_STREAM,0);//IPV4流式套接
      if(listen_sock<0){
        std::cerr<<"监听套接字创建失败"<<std::endl;
        exit(-1);
      }
      //绑定
      struct sockaddr_in local;
      memset(&local,'\0',sizeof(local));//初始化结构体
      local.sin_family=AF_INET;
      local.sin_port=htons(port);//主机转网络
      local.sin_addr.s_addr=INADDR_ANY;//随机绑定服务器ip
      if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0){
        std::cerr<<"绑定失败"<<std::endl;
        exit(-2);
      }
      //建立链接
#define BACK_LOG 5
      if(listen(listen_sock,BACK_LOG)<0){
        std::cerr<<"链接失败"<<std::endl;
        exit(-3);
      }
      std::cout<<"服务启动成功"<<std::endl;
      Pool=new ThreadPool<Task>(10);//10个线程

    }

    //获取链接
    void Loop()
    {
      Pool->InitThreadPool();
      //获取客户端信息
      struct sockaddr_in client;
      //signal(SIGCHID,hander);//hander是信号捕捉方法
      while(true)
      {
        socklen_t len=sizeof(client);
        //获取新链接
        int sock=accept(listen_sock,(struct sockaddr*)&client,&len);
        if(sock<0){
          std::cerr<<"接受链接失败"<<std::endl;
          continue;//继续接受其他链接请求
        }
        std::string ip=inet_ntoa(client.sin_addr);
        int port=ntohs(client.sin_port);
        Task asig(sock,ip,port);
        Pool->Push(asig);
      }
    }

    ~TcpSever(){
      if(listen_sock>=0){
        close(listen_sock);
      }
    }
};

客户端代码不需要改变 

凤 曦
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【网络编程】用于echo回显测试的TCP服务器的设计
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
12-06 2万+
TCP echo 服务器，一个很简单用于测试网络通讯的小demo。
Python 网络编程入门——用 Socket 做一个风花雪月服务器
Python作业辅导员 - 天元浪子
11-26 7883
理解 TCP/IP，是程序员从初阶到高阶的必由之路。然而，现在的程序员几乎没有多少实战机会接触到网络编程比较底层的部分。究其原因，一方面是因为流行的网络引擎框架提供了很好的封装，另一个原因是应用层面上多以 http/ftp 等协议为主，程序员不需要从 Socket 做起了。
Linux_套接字（C++_TCP回显服务器——多进程/线程池(生产者消费者模型)处理多链接请求）
dodamce的博客
02-21 2215
文章目录1.多进程版本服务端启动服务端客户端启动客户端本地测试2.多线程版本3.模板线程池版本线程池代码：设计任务Task.h服务端代码 1.多进程版本 这里选择创建子进程，让子进程再创建子进程。父进程等待子进程，子进程的子进程处理业务逻辑。因为子进程是直接退出，子进程的子进程变成孤儿进程被系统管理，所以父进程在等待的时候不是阻塞等待的，所以可以处理多条链接请求。 或者可以忽略SIGCHID信号让子进程不需要等待。 服务端 pragma once #include<iostream> #in
网络和Linux网络_3(套接字编程)TCP网络通信代码(多个版本)
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-18 747
网络和Linux网络_3（套接字编程）TCP网络通信代码（单进程版+多进程版+多线程版，常规打印，大小写转化，在线翻译）。下一篇：应用层_序列化和反序列化_网络计算器。
【Linux网络】 网络套接字（三）socket编程_TCP网络程序
fufufu_的博客
07-24 564
TCP创建套接字并绑定的过程和UDP创建套接字并绑定的过程一样，这里对一些参数进行说明。 TCP服务器在调用socket函数创建套接字时，参数设置如下：UDP服务器的初始化只需要上述的创建套接字并绑定，因为UDP是面向数据报服务的，负责把消息传递即可。而TCP服务器是面向连接的，客户端在正式向TCP服务器发送数据之前需要进行连接，才能进行通信。因此TCP服务端需要时刻监听客户端是否发来连接请求，那么我们上面创建的套接字需要用来监听。设置套接字为监听状态的函数叫做listen，该函数的函数原型如下： 参数说明
【网络篇】第十篇——线程池版的TCP网络程序
m0_58367586的博客
11-13 632
其中在线程池里面有一个任务队列，当有新的任务到来的时候，就可以将任务Push到线程池当中，在线程池当中我们默认创建了5个线程，这些线程不断检测任务队列当中是否有任务，如果有任务就拿出任务，然后调用该任务对应的Run函数对该任务进行处理，如果线程池当中没有任务那么当前线程就会进入休眠状态。此时当客户端连接服务器后，服务端的主线程就会获取该客户端的连接请求，并将其封装为一个任务对象后塞入任务队列，此时线程池中的5个线程就会有一个线程从任务队列当中获取到该任务，并执行该任务的处理函数为客户端提供服务。
linux 命令：nc、netcat、ncat、socat
墨鱼菜鸡
07-11 6346
参考 ：http://www.linuxso.com/command/nc.html NC工具的使用说明教程：https://blog.csdn.net/xysoul/article/details/52270149 window 版本 nc 下载：https://eternallybored.org/misc/netcat/ 1、nc、ncat...
C++教程网视频：linux网络编程
05-15
### C++教程网视频：Linux网络编程 #### Linux网络编程之TCP/IP基础篇 ##### TCPIP基础（一） - **ISO/OSI参考模型**：ISO/OSI模型分为七层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层...
11.1网络编程
lbjbs的博客
05-16 457
首先在主线程中创建两个线程，分别执行生产者和消费者函数。定义公共资源，注意写在全局区，不能写在main函数里。定义信号量，并记得对信号量进行初始化。编写生产者与消费者中的内容，两个线程的函数都是一个死循环。
【Linux】进程间通信（IPC）（第十四篇）
abclui的专栏
09-05 1494
进程用户空间是相互独立的，一般而言是不能相互访问的。但很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其它进程之间的互相通信来协调它们的行为。1.进程间通信的应用场景数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
损坏SD数据恢复的8种有效方法
u011000995的博客
09-08 829
无论是处理标准SD卡还是专门的硬盘录像机数据恢复 情况下，了解最新的数据恢复工具的进步是必不可少的。当你的SD卡坏了，你可以做的第一件事是使用工具来找回你的信息。如果您的SD卡坏了，您需要SD数据恢复来获取您的信息。在其他情况下，您不应继续执行此步骤。有可能你将能够再次使用SD卡恢复，如果你发现你不能这样做，你可能会找到可以恢复SD卡的软件。当涉及从标准软件无法修复的损坏或严重损坏的SD卡中恢复数据时，大多数时候，最有效的方法是聘请专业人员。问题可能不是SD卡的问题，而是计算机或您使用的USB端口的问题。
使用 Spring Boot + MinIO 实现文件的分片上传、秒传、续传功能开发
智轩软件的专栏
09-07 672
MinIO传文件
云原生之WEB应用服务器Tomcat（持续更新中）
小刘在努力的博客
09-07 1073
带你了解企业级web应用服务器--Tomcat
Windows系统怎么免费远程控制电脑？
2301_79638883的博客
09-06 817
​在Windows系统中除了远程桌面可以控制电脑外，您还可以使用Windows远程协助远程控制另外一台电脑。Windows远程协助是通过邀请文件和密码来远程控制电脑的，您可以按照以下步骤来远程控制电脑。
要在 Windows 系统中通过 VNC 远程连接到 CentOS 或 Ubuntu 服务器，可以按照以下步骤来配置和使用 VNC 进行远程桌面访问
NTD_huachen的博客
09-06 1657
要在 Windows 系统中通过 VNC 远程连接到 CentOS 或 Ubuntu 服务器，可以按照以下步骤来配置和使用 VNC 进行远程桌面访问
Linux：epoll 工作模式
最新发布
MaoRuofeng的博客
09-10 773
和是epoll两种不同的工作模式，它们在处理I/O事件时有不同的行为。
Shell脚本基本语法(Linux篇)
m0_67771087的博客
09-05 1418
用户自定义的变量也叫本地变量，只在定义它的当前shell中才也可以使用。参考变量定义中的变量赋值即可。参数说明最后一次执行命令的返回状态，如值为0则说明成功，如值为非0，则说明命令执行不正确$$当前进程的进程号后台运行的最后一个进程的进程号02。
腾讯云 Nginx 服务器 SSL 证书安装部署（Linux）
09-05 1014
说明里面443端口是在linux防火墙里面开的，但是需要注意的是要开放防火墙的话一定要同时开放SSH，也就是在防火墙配置文件里面同时写上SSH的端口，否则你用XShell这些远程工具连服务器的时候，你就会哭了。#例如，您的网站主页在 Nginx 服务器的 /etc/www 目录下，则请修改 root 后面的 html 为 /etc/www。其实在线安装nginx比较方便，大家自然可以去查，但是在线安装nginx在有些系统上他就是出各种各样的幺蛾子，所以我在这里主张离线安装了。没开放都有可能会引起访问不到。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值