Linux学习之路（20）

最新推荐文章于 2023-07-22 13:02:44 发布
最新推荐文章于 2023-07-22 13:02:44 发布
阅读量124 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39584766/article/details/85637214
版权

1、tcp_client.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
 #include <netinet/in.h>

// 子线程负责写数据
void *write_data(void *v)
{
    int client_socket = *(int*)v;
    char buf[1024];
    while (1)
    {
        fgets(buf, 1024, stdin);
        write(client_socket, buf, strlen(buf));
    }    
}

// 主线程负责读数据
void read_data(int client_socket)
{
    char buf[1024] = {"asdsadsadsadsa"};
    while (1)
    {
        int ret = read(client_socket, buf, sizeof(buf)-1);
        if (-1 == ret)
        {
            perror ("read error");
        }
        if (0 == ret)
        {
            printf ("客户端退出\n");
            break;
        }
        buf[ret] = '\0';
        printf ("%s\n", buf);
    }    
}

int main(int argc, char **argv)
{
    // 1、创建套接字
    int conn_socket = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == conn_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    // 2、连接服务器
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;                      /* Internet地址族 */
    addr.sin_port        = htons(atoi(argv[2]));         /*服务器用的端口号 */
    addr.sin_addr.s_addr = inet_addr(argv[1]);           /*服务器用的IP地址 */
    int ret = connect(conn_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if (-1 == ret)
    {
        perror("连接服务器失败");
        return -1;
    }
    
    pthread_t thread;
    pthread_create(&thread, NULL, write_data, (void *)&conn_socket);
    
    read_data(conn_socket);
    
    close(conn_socket);
    
    return 0;
}
 

 

2、多进程并发网络编程

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>

#define  PORT   9998

void handl_client(int client_socket)
{
    char buf[1024] = {"asdsadsadsadsa"};
    while (1)
    {
        int ret = read(client_socket, buf, sizeof(buf)-1);
        if (-1 == ret)
        {
            perror ("read error");
            break;
        }
        if (0 == ret)
        {
            printf ("客户端退出\n");
            break;
        }
        buf[ret] = '\0';
        printf ("收到客户端数据：%s\n", buf);
        int i;
        for (i = 0; i < ret-1; i++)
        {
            buf[i] += 'A' - 'a';
        }
        write(client_socket, buf, ret);
    }    
}


// 监听套接字
int init()
{
    int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == listen_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;             /* Internet地址族 */
    addr.sin_port        = htons(PORT);         /* 端口号 */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址, 绑定本地的所有ip地址*/

    int ret = bind(listen_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if(-1 == ret)
    {
        perror("绑定失败");
        return -1;
    }
    
    // 3、监听套接字
    ret = listen(listen_socket, 5);
    if(-1 == ret)
    {
        perror("监听失败");
        return -1;
    }
    
    return listen_socket;
}

// 通信套接字
int myAccept(int listen_socket)
{
    struct sockaddr_in client_addr;
    socklen_t  len = sizeof(client_addr);
    int client_socket = accept(listen_socket, (struct sockaddr *)&client_addr, &len);
    if (-1 == client_socket)
    {
        perror("accept  失败");
        return -1;
    }
    
    printf ("客户端的 ip = %s, 端口 = %d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
    
    return client_socket;
}

 

int main(int argc, char **argv)
{
    int listen_socket = init();
    if (-1 == listen_socket)
        return;
    
    while (1)
    {
        int client_socket = myAccept(listen_socket);
        
        pid_t pid = fork() ;// 创建子进程为客户端服务
        switch(pid)
        {
            case -1:
                perror("fork失败");
                break;
            case 0:   // 子进程
                close(listen_socket);          // 关闭监听套接字
                handl_client(client_socket);  // 处理客户端请求
                close(client_socket);         // 关闭通信套接字
                break;
            default:  // 父进程
                close(client_socket);         // 关闭通信套接字
                break;
        }
    }
    
    
    close(listen_socket);

    
    return 0;
}
 

 

3、多线程并发网络编程

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#define  PORT   9998

void *handl_client(void *v)
{
    long client_socket = (long)v;
    
    char buf[1024] = {"asdsadsadsadsa"};
    while (1)
    {
        int ret = read(client_socket, buf, sizeof(buf)-1);
        if (-1 == ret)
        {
            perror ("read error");
            break;
        }
        if (0 == ret)
        {
            printf ("客户端退出\n");
            break;
        }
        buf[ret] = '\0';
        printf ("收到客户端数据：%s\n", buf);
        int i;
        for (i = 0; i < ret-1; i++)
        {
            buf[i] += 'A' - 'a';
        }
        write(client_socket, buf, ret);
    }    
}


// 监听套接字
int init()
{
    int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == listen_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;             /* Internet地址族 */
    addr.sin_port        = htons(PORT);         /* 端口号 */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址, 绑定本地的所有ip地址*/

    int ret = bind(listen_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if(-1 == ret)
    {
        perror("绑定失败");
        return -1;
    }
    
    // 3、监听套接字
    ret = listen(listen_socket, 5);
    if(-1 == ret)
    {
        perror("监听失败");
        return -1;
    }
    
    return listen_socket;
}

// 通信套接字
int myAccept(int listen_socket)
{
    struct sockaddr_in client_addr;
    socklen_t  len = sizeof(client_addr);
    int client_socket = accept(listen_socket, (struct sockaddr *)&client_addr, &len);
    if (-1 == client_socket)
    {
        perror("accept  失败");
        return -1;
    }
    
    printf ("客户端的 ip = %s, 端口 = %d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
    
    return client_socket;
}

 

int main(int argc, char **argv)
{
    int listen_socket = init();
    if (-1 == listen_socket)
        return;
    
    while (1)
    {
        long client_socket = myAccept(listen_socket);
        if (-1 == client_socket)
        {
            continue;
        }
        
        // 开辟线程为客户端服务
        pthread_t thread;
        pthread_create(&thread, NULL, handl_client, (void *)client_socket);
        
        
        pthread_detach(thread);   // 线程分离
    }
    
    
    close(listen_socket);

    
    return 0;
}

 

4、简单聊天

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#define  PORT   9997

int socket_fd[2];

void *handl_client(void *v)
{
    long i = (long)v;
    
    char buf[1024] = {"asdsadsadsadsa"};
    while (1)
    {
        int ret = read(socket_fd[i], buf, sizeof(buf)-1);
        if (-1 == ret)
        {
            perror ("read error");
            break;
        }
        if (0 == ret)
        {
            printf ("客户端退出\n");
            break;
        }

        write(socket_fd[1-i], buf, ret);
    }    
}


// 监听套接字
int init()
{
    int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == listen_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;             /* Internet地址族 */
    addr.sin_port        = htons(PORT);         /* 端口号 */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址, 绑定本地的所有ip地址*/

    int ret = bind(listen_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if(-1 == ret)
    {
        perror("绑定失败");
        return -1;
    }
    
    // 3、监听套接字
    ret = listen(listen_socket, 5);
    if(-1 == ret)
    {
        perror("监听失败");
        return -1;
    }
    
    return listen_socket;
}

// 通信套接字
int myAccept(int listen_socket)
{
    struct sockaddr_in client_addr;
    socklen_t  len = sizeof(client_addr);
    int client_socket = accept(listen_socket, (struct sockaddr *)&client_addr, &len);
    if (-1 == client_socket)
    {
        perror("accept  失败");
        return -1;
    }
    
    printf ("客户端的 ip = %s, 端口 = %d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
    
    return client_socket;
}


int main(int argc, char **argv)
{
    int listen_socket = init();
    if (-1 == listen_socket)
        return;
    
    long i = 0;
    while (i < 2)
    {
        socket_fd[i] = myAccept(listen_socket);
        if (-1 == socket_fd[i])
        {
            continue;
        }
        
        // 开辟线程为客户端服务
        pthread_t thread;
        pthread_create(&thread, NULL, handl_client, (void *)i);
        
        
        pthread_detach(thread);   // 线程分离
        i++;
    }
    
    
    close(listen_socket);

    pthread_exit(NULL);
    return 0;
}
 

 

5、udp服务器

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#define  PORT   9998

void handl_client(char *buf)
{
    int i;
    for (i = 0; i < strlen(buf)-1; i++)
    {
        buf[i] += 'A' - 'a';
    }
}


// 监听套接字
int init()
{
    int conm_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if(-1 == conm_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;             /* Internet地址族 */
    addr.sin_port        = htons(PORT);         /* 端口号 */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址, 绑定本地的所有ip地址*/

    int ret = bind(conm_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if(-1 == ret)
    {
        perror("绑定失败");
        return -1;
    }
    
    return conm_socket;
}

int main(int argc, char **argv)
{
    int conm_socket = init();
    if (-1 == conm_socket)
        return;
    
    char buf[1024];
    while (1)
    {
        struct sockaddr_in client_addr;
        socklen_t  len = sizeof(client_addr);
        ssize_t ret = recvfrom(conm_socket, buf, 1023, 0, (struct sockaddr *)&client_addr, &len);// 收
        buf[ret] = '\0';
        handl_client(buf);     // 处理
        
        sendto(conm_socket, buf, ret, 0, (struct sockaddr *)&client_addr,  len);// 回
    }
    
    
    return 0;
}

 

6、2、udp_client.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
 #include <netinet/in.h>

// 子线程负责写数据
void *write_data(void *v)
{
    int conm_socket = *(int*)v;
    
    char buf[1024];
    while (1)
    {
        struct sockaddr_in client_addr;
        socklen_t  len = sizeof(client_addr);
        ssize_t ret = recvfrom(conm_socket, buf, 1023, 0, (struct sockaddr *)&client_addr, &len);// 收
        if (-1 == ret)
        {
            perror ("read error");
        }
        if (0 == ret)
        {
            printf ("客户端退出\n");
            break;
        }
        buf[ret] = '\0';
        printf ("%s\n", buf);
    }    
}

// 主线程负责读数据
void read_data(int conm_socket, char **argv)
{

    // 接收方的地址
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;                      /* Internet地址族 */
    addr.sin_port        = htons(atoi(argv[2]));         /*服务器用的端口号 */
    addr.sin_addr.s_addr = inet_addr(argv[1]);           /*服务器用的IP地址 */
    
    char buf[1024];
    while (1)
    {
        fgets(buf, 1024, stdin);
        sendto(conm_socket, buf, strlen(buf), 0, (struct sockaddr *)&addr,  sizeof(addr));
    }    
    
}

int main(int argc, char **argv)
{
    // 1、创建套接字
    int conn_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if(-1 == conn_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    pthread_t thread;
    pthread_create(&thread, NULL, write_data, (void *)&conn_socket);
    
    read_data(conn_socket, argv);
    
    close(conn_socket);
    
    return 0;
}
 

 

7、并发.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#define  PORT   9998

int conm_socket; 

typedef struct _msg
{
    char buf[256];
    struct sockaddr_in client_addr;
}Msg;

Msg task[100];   // 任务
int front = 0;
int rear  = 0;


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  // 互斥锁
pthread_cond_t cond1;    // 条件变量


void handl_client(Msg *data)
{
    int i;
    for (i = 0; i < strlen(data->buf)-1; i++)
    {
        data->buf[i] += 'A' - 'a';
    }
    
    sendto(conm_socket, data->buf, strlen(data->buf), 0, (struct sockaddr *)&(data->client_addr),  sizeof(data->client_addr));// 回
}


// 监听套接字
int init()
{
    int conm_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if(-1 == conm_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;             /* Internet地址族 */
    addr.sin_port        = htons(PORT);         /* 端口号 */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址, 绑定本地的所有ip地址*/

    int ret = bind(conm_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if(-1 == ret)
    {
        perror("绑定失败");
        return -1;
    }
    
    return conm_socket;
}

void *consume(void *v)
{
    while (1)
    {
        Msg data;
        pthread_mutex_lock(&mutex);
        while (rear == front)
        {
            pthread_cond_wait(&cond1, &mutex);
        }
        
        front = (front+1)%20;
        data = task[front];
        
        pthread_mutex_unlock(&mutex);
        
        handl_client(&data);
    }
}

void  produce()
{
    char buf[1024];
    while (1)
    {
        struct sockaddr_in client_addr;
        socklen_t  len = sizeof(client_addr);
        ssize_t ret = recvfrom(conm_socket, buf, 1023, 0, (struct sockaddr *)&client_addr, &len);// 收
        buf[ret] = '\0';
        
        printf ("[%s:%d] %s", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buf);
        
        pthread_mutex_lock(&mutex);
        
        if ((rear+1)%20 == front)
            continue;
        
        rear = (rear+1)%20;
        strcpy(task[rear].buf, buf);
        task[rear].client_addr = client_addr;
        
        pthread_cond_broadcast(&cond1);     // 广播
        pthread_mutex_unlock(&mutex);    
    }
}

int main(int argc, char **argv)
{
    long i;
    pthread_t thread;
    for (i = 0; i < 8; i++)
    {
        pthread_create(&thread, NULL, consume, (void*)(i+1));
        pthread_detach(thread);
    }
    
    pthread_cond_init(&cond1, NULL);
    
    conm_socket = init();
    if (-1 == conm_socket)
        return;
    
    produce();
    
    return 0;
}

 

8、多路复用

tcp_server.c

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


#define SIZE 1024
#define PORT 9999

// sfd 用于和客户端通信
void handl_client(int sfd, fd_set *allset)
{
    char buf[SIZE] = {0};
    int ret = read (sfd, buf, SIZE-1);
    if (ret == -1)
    {
        perror ("read");
        return;
    }
    if (ret == 0)
    {
        printf ("客户端退出\n");
        FD_CLR(sfd, allset);
        return;
    }
    buf[ret] = '\0';
    printf ("read %d bytes : %s\n", ret, buf);
    
    int i; 
    for (i = 0; i < ret - 1; i++)
    {
        buf[i] = buf[i] + 'A' - 'a';
    }
    
    ret = write (sfd, buf, ret);
}

// 监听套接字
int init()
{
    int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == listen_socket)
    {
        perror("创建套接字失败");
        return -1;
    }
    
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family      = AF_INET;             /* Internet地址族 */
    addr.sin_port        = htons(PORT);         /* 端口号 */
    addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址, 绑定本地的所有ip地址*/

    int ret = bind(listen_socket, (const struct sockaddr *)&addr, sizeof(addr));
    if(-1 == ret)
    {
        perror("绑定失败");
        return -1;
    }
    
    // 3、监听套接字
    ret = listen(listen_socket, 5);
    if(-1 == ret)
    {
        perror("监听失败");
        return -1;
    }
    
    return listen_socket;
}

// 通信套接字
int myAccept(int listen_socket)
{
    struct sockaddr_in client_addr;
    socklen_t  len = sizeof(client_addr);
    int client_socket = accept(listen_socket, (struct sockaddr *)&client_addr, &len);
    if (-1 == client_socket)
    {
        perror("accept  失败");
        return -1;
    }
    
    printf ("客户端的 ip = %s, 端口 = %d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
    
    return client_socket;
}


int main()
{
    // 初始化套接字
    int listen_fd = init();
    if (listen_fd == -1)
        return -1;
    

    int maxfd = listen_fd;
    fd_set allset;
    fd_set rset;
    
    FD_ZERO(&allset);              // 将文件描述符集清空 
    FD_SET(listen_fd, &allset);    // 将监听文件描述符加入到监听序列
    
    int client_fd[FD_SETSIZE];     // 代表select能够检测客户端数量
    
    // 对数组进行初始化，全部置为-1，凡是值为-1的位置，都是空位置
    int i;
    for (i = 0; i < FD_SETSIZE; i++)
    {
        client_fd[i] = -1;
    }
    
    while (1)
    {
        rset = allset;
        int count = select(maxfd + 1, &rset, NULL, NULL, NULL);
        if (count == -1)
        {
            perror ("select");
            break;
        }
        
        if (FD_ISSET(listen_fd, &rset))  // 查看是否有客户端要连接
        {
            int conn_fd = myAccept(listen_fd);
            if (conn_fd == -1)
            {
                continue;
            }
            
            // 找个空位置存与客户端通信的文件描述符
            for (i = 0; i < FD_SETSIZE; i++)
            {
                if (client_fd[i] == -1)     // 找到一个空位置
                {
                    client_fd[i] = conn_fd;
                    break;
                }
            }
            
            // 判断文件描述符集是否已达上限
            if (i == FD_SETSIZE)
            {
                close (conn_fd);
            }
            else
            {
                FD_SET(conn_fd, &allset);
                if (maxfd < conn_fd)
                    maxfd = conn_fd;
            }
            
            if (--count <= 0)
                continue;
        }
        
        for (i = 0; i < FD_SETSIZE; i++)
        {
            if (client_fd[i] == -1)
                continue;
            
            if (FD_ISSET(client_fd[i], &rset))
            {
                handl_client(client_fd[i], &allset);
                if (--count <= 0)
                    break;
            }
        }
    }
    
    close (listen_fd);
    return 0;
}

 

一兮1211
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux之学习之路
码莎拉蒂
02-13 3025
很多同学接触Linux不多，对Linux平台的开发更是一无所知。 而现在的趋势越来越表明，作为一个优秀的软件开发人员，或计算机IT行业从业人员， 掌握Linux是一种很重要的谋生资源与手段。 下来我将会结合自己的几年的个人开发经验，及对 Linux，更是类UNIX系统，及开源软件文化， 谈谈Linux的学习方法与学习中应该注意的一些事。 就如同刚才说的，很多同学以前可能连Linux是什么都不知
嵌入式+LINUX+C++学习路线图_PDF(2020.09.20).rar
09-20
标签还提到了“嵌入式+LINUX+C++学习路”，这是强调学习过程中需要关注这三个关键点：嵌入式系统基础知识，Linux操作系统理解和应用，以及C++编程技能的提升。 从压缩包内的文件名称列表可以看出，包含了一系列相关...
多进程tcp服务器
weixin_43667336的博客
01-02 236
#include &lt;stdio.h&gt; #include &lt;sys/types.h&gt; /* See NOTES */ #include &lt;sys/socket.h&gt; #include &lt;arpa/inet.h&gt; #include &lt;string.h&gt; #include &lt;unistd.h&gt; #define P...
socket
腾空烈鹰
04-10 206
最近遇到socket相关内容，故整理一下，方便日后查阅 server #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <arpa/inet.h> #define BUFSIZE 1024 int main...
udp客户端
ypjsdtd的博客
01-03 211
#include &lt;stdio.h&gt; #include &lt;sys/types.h&gt; /* See NOTES */ #include &lt;sys/socket.h&gt; #include &lt;arpa/inet.h&gt; #include &lt;string.h&gt; #include &lt;unistd.h&gt; #include &am
实验八 进程间通信+多线程
diOSyu的博客
09-24 2278
一、实验目的 1、了解采用进程间通信的原理； 2、掌握线程的创建及使用方法，学习进行多线程编程。 二、实验内容 （1）在Linux系统下编写完成。 （2）创建一个服务器和若干个客户端。 （3）用户可以实现包括：通过客户端输入文字并且向服务器发送消息，也可以接收来自服务器端的数据。用户控制客户端退出。 （4）服务器端可以实现包括：接收并区分来自客户端的数据，将用户输入的内容在服务器上打...
大数据学习之Linux基础
时间静止
10-18 3万+
大数据学习之Linux基础 自定义Linux虚拟机安装网络配置1.node1网络配置2.通过快照克隆虚拟机3.配置其他三个节点虚拟机Linux简单命令shell命令运行原理图1.关机与重启2.判断命令的命令3.常用功能命令4.文件系统命令文件系统层次化标准(File System Hierarchy Standard)5.文本操作命令vi全屏文本编辑器全屏编辑器模式1.打开文件2.关闭文件3.编辑...
Linux学习之expect操作详解
jh035的博客
11-22 1万+
1.expect命令安装安装语句:yum install expect2.expect命令含义expect是一种脚本语言，它能够代替人工实现与终端的交互，主要应用于执行命令和程序时，系统以交互形式要求输入指定字符串，实现交互通信。3.expect使用场景（1）并根据预定标准回答其问题，回答“是”、“否”或将控制权交还给您（2）远程连接设备并执行自动化操作（3）主要是一些需要人机交互的地方，如果提前知道应该输入什么指令都可以使用expect 工具。
Linux学习之Ubuntu 20.04安装5.4.0内核
qq_42108074的博客
07-22 5646
键可以选择选项，比如，< Exit >等。要是只有如下所示一条记录，要么执行完成，要么有问题报错了。编译过程，按一下回车键可以再次进入命令输出。最后三十行输出结果，发现没有报错，结合上边。之后按一下回车键，接着让系统进行编译吧。已经执行结束，这说明内核已经编译成功了。键，选择 < Save >，然后按。键，选择 < Exit >，然后按。键，选择 < Exit >，然后按。键，选择 < Exit >，然后按。键，选择 < ok >，然后按。可以看一下文件里边的内容。，看一下可以下载的源码。
Linux学习笔记-B站韩顺平
m0_52041525的博客
02-26 2万+
linux 是一个开源、免费的操作系统，其稳定性、安全性、处理多并发已经得到业界的认可，
Linux学习笔记——CentOS
热门推荐
MCC
04-20 3万+
Linux1 介绍2 安装3 Linux 的目录结构4 远程操作工具5 1 介绍 Linux 是一个开源、免费的操作系统，具有很强的稳定性、安全性、以及处理多并发的能力，目前大多数企业级应用甚至是集群项目都部署运行在 Linux 操作系统上，很多软件公司考虑到开发成本都首选Linux，Linux 在中国软件公司得到了广泛的使用。 Linux 的主要发行版本有以下几种： Ubuntu（乌班图）、RedHat（红帽）、CentOS、Debain（蝶变）、Fedora、SuSE、OpenSUSE、红旗Li
EC20 Linux驱动.rar
05-18
3. "Quectel_Linux_USB_Drivers_Sample_V1.0.0.zip"：这个文件可能是EC20 USB驱动的示例代码或者库，供开发人员参考和学习如何在自己的应用程序中使用驱动，包含了如何与EC20模块进行通信的实例。 总的来说，这个...
linux 学习
09-04
Linux 系统是当今最流行的操作系统之一，学习 Linux 是非常重要的。本文将总结 Linux 中常用的命令、系统概念和知识点，以便读者更好地理解和学习 Linux。 一、Linux 命令 1. man 命令：Manual 的缩写，用于查询...
数据结构试题参考及答案.doc
08-29
内容概要：本资源提供了一份详尽的数据结构试题参考及答案，覆盖了从基础概念到复杂算法的多个层面。读者可以通过这份材料，系统地学习和复习数据结构的理论知识和应用实践，包括但不限于时间复杂度分析、线性表操作、树与图的遍历、排序算法等。 适合人群：适合计算机科学与技术专业的学生、准备数据结构考试或面试的研发人员，以及任何希望提升数据结构和算法知识的编程爱好者。 能学到什么： 1. 如何分析和计算算法的时间复杂度，掌握不同算法性能评估的方法。 2. 线性表的存储结构，包括顺序表和链表的特点及其操作实现。 3. 图和树的遍历算法，理解深度优先搜索和广度优先搜索的应用场景。 4. 排序算法的原理和实现，包括快速排序、归并排序等。 5. 哈希表的设计与冲突解决策略，理解哈希函数的重要性。 6. 递归算法和非递归算法的设计思想，学习如何选择合适的算法实现。 阅读建议：此资源不仅包含了数据结构的基础知识点，还提供了丰富的例题和解答，适合读者进行自我测试和深化理解。在学习过程中，建议结合实际编程实践，将理论知识应用到具体的算法实现中。同时，鼓励读者在理解的基础上，自行推导和验证答案，以加深记忆和理解。
有住网（装修小程序源码）.zip
08-29
有住网（装修小程序源码）.zip
d3dcsx_46.dll
08-29
Windows 8 SDK 此 SDK 于 2012 年 11 月发布，可用于创建适用于 Windows 8 或更早版本的 Windows 应用 () 使用 Web 技术、本机和托管代码;或使用本机或托管编程模型的桌面应用。
汇编语言I/O专题教程.ppt
最新发布
08-29
资源描述： 内容概要：《汇编语言》资源是一本深入浅出介绍汇编编程语言的教程，覆盖了从基础语法到高级程序设计技巧的全方位知识。通过本教程，读者将学习到汇编语言的基本概念、输入输出程序设计、中断处理、以及如何利用汇编语言直接控制硬件等核心内容。 适合人群：本资源适合对计算机底层工作原理感兴趣的学习者，包括计算机科学专业的学生、嵌入式系统开发者、硬件工程师以及任何希望深入理解计算机系统工作的编程爱好者。 能学到什么： 1. 汇编语言的基础知识，包括指令集、寄存器使用、内存管理等。 2. I/O设备的数据传送方式，如无条件传送、查询式传送和中断传送方式。 3. 程序直接控制I/O方式，包括I/O端口的使用、I/O指令的应用以及实际的I/O程序设计示例。 4. 中断传送方式的工作原理和实现，包括中断类型、中断向量表、中断处理过程和中断优先级管理。 5. 汇编语言在性能优化和硬件交互中的应用，以及如何编写高效的I/O程序。 6. 实际的汇编程序设计技巧，如发声程序、打印字符程序和中断处理程序的编写。 阅读建议：此资源不仅注重代码的编写实现，也强调对汇编语言程序设计背后的原理和硬件操作的理解
提供题库的创建和管理，试卷的设计和管理，考试的安排和管理，灵活的评分系统，全面的分析系统以及及时的反馈系统.zip
08-29
提供题库的创建和管理，试卷的设计和管理，考试的安排和管理，灵活的评分系统，全面的分析系统以及及时的反馈系统，为用户量身打造适合自己
手写迷你mybatis框架，里面使用了mybatis设计模式和框架.zip
08-29
手写迷你mybatis框架，里面使用了mybatis设计模式和框架
busybox linux使用教程,linux学习之路之busybox使用
06-13
解水池 A 和水池 B 的水位随时间变化的微分方程组 function [dhAdt, dhBusyBox是一个开源项目，它提供了一个精简的Unix工具集，可以在一个小型的嵌入Bdt] = water_tank_ode(t, hA, hB) % 参数设置 AA = 10; %式系统中运行。在本教程中，我们将学习如何使用BusyBox来构建一个基本的Linux 水池 A 的底面积，单位为平方米 AB = 20; % 水池 B 的底面积，系统。 1. 下载BusyBox 首先，你需要从BusyBox官网（https://www.busybox.net/downloads/单位为平方米 qin = 5; % 水池 A 的进水量，单位为立方米/小时）下载最新的tar包。 2. 解压并编译BusyBox 将tar包解压到一个目录中，并 qout = 3; % 水池 A 的出水量，单位为立方米/小时 qtransfer =使用以下命令编译BusyBox： ``` tar -xjf busybox-x.x.x.tar.bz2 cd busybox-x.x 2; % 水池 A 和水池 B 之间的水量转移，单位为立方米/小时 .x make defconfig make ``` 这将编译BusyBox，并生成一个可执行文件。 3. 安装BusyBox quse = 4; % 水池 B 的出水量，即城市用水量，单位为立方米/小时 使用以下命令安装BusyBox： ``` make install ``` 这将安装BusyBox二进制文件到目 % 微分方程组 dhAdt = (qin - qout - qtransfer) / AA; dh录`/bin`中。 4. 构建文件系统 现在，我们需要构建一个文件系统，以便为BusyBdt = (qtransfer - quse) / AB; end % 解微分方程组 [t, h] = odeBox提供根文件系统。可以使用以下命令构建文件系统： ``` mkdir rootfs cd rootfs mkdir -45(@water_tank_ode, [0, 24], [3, 5]); % 画图 plot(t, hp {bin,etc,dev,proc,sys,usr} ``` 这将在目录`rootfs`中创建一个基(:, 1), 'r--', t, h(:, 2), 'b--'); xlabel('时间/h'); ylabel('水位/m本的文件系统结构。 5. 复制BusyBox二进制文件 使用以下命令将BusyBox二进制文件'); legend('水池 A', '水池 B'); ``` 运行以上代码，将得到水池 A 和水池 B 的水位随时间变化的图表结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值