linux多线程搭建服务器

已于 2024-08-06 16:27:22 修改
阅读量233 收藏 4
点赞数 4
文章标签： linux
于 2024-08-05 16:59:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42477169/article/details/140931490
版权

服务端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>

#define PORT 8080
#define BUFFER_SIZE 1024

void *connection_handler(void *socket_desc) {
int sock = *(int *)socket_desc;
char buffer[BUFFER_SIZE] = {0};
char *response = “HTTP/1.1 200 OK\nContent-Type: text/html\n\n

Hello, World!

\n”; 

read(sock, buffer, BUFFER_SIZE);
printf("Received request:\n%s\n", buffer);

write(sock, response, strlen(response));
close(sock);

free(socket_desc);

return NULL;

}

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int addrlen = sizeof(address);

// Create socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("socket failed");
    exit(EXIT_FAILURE);
}

address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// Bind socket to localhost:PORT
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
    perror("bind failed");
    exit(EXIT_FAILURE);
}

// Listen for incoming connections
if (listen(server_fd, 3) < 0) {
    perror("listen failed");
    exit(EXIT_FAILURE);
}
printf("Server listening on port %d\n", PORT);

// Accept incoming connections and handle them using threads
while (1) {
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
        perror("accept failed");
        exit(EXIT_FAILURE);
    }

    printf("Connection accepted\n");

    pthread_t thread;
    int *new_sock = malloc(1);
    *new_sock = new_socket;

    if (pthread_create(&thread, NULL, connection_handler, (void *)new_sock) < 0) {
        perror("could not create thread");
        return 1;
    }

    // Detach the thread, so it will clean up after itself
    pthread_detach(thread);
}

return 0;

}

完善客户请求处理

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <fcntl.h>

#define PORT 8080
#define BUFFER_SIZE 1024

void send_response(int socket, int status, char* content_type, char* content) {
char response[BUFFER_SIZE] = {0};
char headers[BUFFER_SIZE] = {0};

sprintf(headers, "HTTP/1.1 %d ", status);
switch(status) {
    case 200:
        strcat(headers, "OK\r\n");
        break;
    case 404:
        strcat(headers, "Not Found\r\n");
        break;
    default:
        strcat(headers, "Internal Server Error\r\n");
}

sprintf(response, "%sContent-Type: %s\r\n\r\n%s", headers, content_type, content);
send(socket, response, strlen(response), 0);

}

void handle_request(int new_socket) {
char buffer[BUFFER_SIZE] = {0};
char method[10], path[255], protocol[20];

read(new_socket, buffer, BUFFER_SIZE);
sscanf(buffer, "%s %s %s", method, path, protocol);

if(strcmp(method, "GET") == 0) {
    char file_path[255] = {0};
    sprintf(file_path, ".%s", path);
    
    // Open requested file
    int fd = open(file_path, O_RDONLY);
    if(fd == -1) {
        send_response(new_socket, 404, "text/html", "<h1>404 Not Found</h1>");
    } else {
        struct stat file_stat;
        fstat(fd, &file_stat);
        char* content_type = "text/html";
        if (strstr(file_path, ".png")) content_type = "image/png";
        if (strstr(file_path, ".jpg")) content_type = "image/jpeg";
        if (strstr(file_path, ".gif")) content_type = "image/gif";
        if (strstr(file_path, ".html")) content_type = "text/html";

        char* content = malloc(file_stat.st_size);
        read(fd, content, file_stat.st_size);
        send_response(new_socket, 200, content_type, content);
        free(content);
    }
} else {
    send_response(new_socket, 500, "text/html", "<h1>500 Internal Server Error</h1>");
}

close(new_socket);

}

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int addrlen = sizeof(address);

// Creating socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
}

// Forcefully attaching socket to the port 8080
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// Binding socket to the specified port
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
    perror("Bind failed");
    exit(EXIT_FAILURE);
}

// Listening for incoming connections
if (listen(server_fd, 3) < 0) {
    perror("Listen failed");
    exit(EXIT_FAILURE);
}

printf("Server listening on port %d\n", PORT);

// Accept incoming connections
while (1) {
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("Accept failed");
        exit(EXIT_FAILURE);
    }

    // Handle incoming request
    handle_request(new_socket);
}

return 0;

}

第三版

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#define PORT 8080
#define BUFFER_SIZE 1024

void send_response(int socket, int status, char* content_type, char* content) {
char response[BUFFER_SIZE] = {0};
char headers[BUFFER_SIZE] = {0};

sprintf(headers, "HTTP/1.1 %d ", status);
switch(status) {
    case 200:
        strcat(headers, "OK\r\n");
        break;
    case 404:
        strcat(headers, "Not Found\r\n");
        break;
    default:
        strcat(headers, "Internal Server Error\r\n");
}

sprintf(response, "%sContent-Type: %s\r\n\r\n%s", headers, content_type, content);
send(socket, response, strlen(response), 0);

}

void* handle_request(void* socket_ptr) {
int new_socket = ((int) socket_ptr);
char buffer[BUFFER_SIZE] = {0};
char method[10], path[255], protocol[20];

read(new_socket, buffer, BUFFER_SIZE);
sscanf(buffer, "%s %s %s", method, path, protocol);

if(strcmp(method, "GET") == 0) {
    char file_path[255] = {0};
    sprintf(file_path, ".%s", path);
    
    // Open requested file
    int fd = open(file_path, O_RDONLY);
    if(fd == -1) {
        send_response(new_socket, 404, "text/html", "<h1>404 Not Found</h1>");
    } else {
        struct stat file_stat;
        fstat(fd, &file_stat);
        char* content_type = "text/html";
        if (strstr(file_path, ".png")) content_type = "image/png";
        if (strstr(file_path, ".jpg")) content_type = "image/jpeg";
        if (strstr(file_path, ".gif")) content_type = "image/gif";
        if (strstr(file_path, ".html")) content_type = "text/html";

        char* content = malloc(file_stat.st_size);
        read(fd, content, file_stat.st_size);
        send_response(new_socket, 200, content_type, content);
        free(content);
    }
} else {
    send_response(new_socket, 500, "text/html", "<h1>500 Internal Server Error</h1>");
}

close(new_socket);
free(socket_ptr);
return NULL;

}

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int addrlen = sizeof(address);

// Creating socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
}

// Forcefully attaching socket to the port 8080
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// Binding socket to the specified port
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
    perror("Bind failed");
    exit(EXIT_FAILURE);
}

// Listening for incoming connections
if (listen(server_fd, 3) < 0) {
    perror("Listen failed");
    exit(EXIT_FAILURE);
}

printf("Server listening on port %d\n", PORT);

// Accept incoming connections and handle in separate threads
while (1) {
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("Accept failed");
        exit(EXIT_FAILURE);
    }

    // Create a new thread to handle the client
    pthread_t thread;
    int* socket_ptr = malloc(sizeof(int));
    *socket_ptr = new_socket;
    if (pthread_create(&thread, NULL, handle_request, (void*) socket_ptr) != 0) {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }
    pthread_detach(thread);  // Detach the thread to avoid memory leaks
}

return 0;

}

修改

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 12345
#define MAX_BUFFER_SIZE 1024

void send_data(int sockfd, const char *data) {
size_t total_sent = 0;
size_t data_len = strlen(data);

while (total_sent < data_len) {
    ssize_t sent = send(sockfd, data + total_sent, data_len - total_sent, 0);
    if (sent == -1) {
        perror("send");
        exit(EXIT_FAILURE);
    }
    total_sent += sent;
}

}

int main() {
int sockfd;
struct sockaddr_in server_addr;
const char *content = “This is the content to be sent to the socket.”;

// 创建socket
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
}

// 设置server_addr结构
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  // 替换为目标服务器的IP地址

// 连接到服务器
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("connect");
    exit(EXIT_FAILURE);
}

// 发送数据
send_data(sockfd, content);

// 关闭socket
close(sockfd);

return 0;

}

加入post处理

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 8080
#define MAX_THREADS 5

void *connection_handler(void *socket_desc);

int main() {
int server_fd, new_socket, c;
struct sockaddr_in address, client_addr;
int opt = 1;
int addrlen = sizeof(address);

// Creating socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("socket failed");
    exit(EXIT_FAILURE);
}

// Forcefully attaching socket to the port 8080
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
    perror("setsockopt");
    exit(EXIT_FAILURE);
}

address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// Bind the socket to localhost port 8080
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0) {
    perror("bind failed");
    exit(EXIT_FAILURE);
}

// Try to specify maximum of 3 pending connections for the master socket
if (listen(server_fd, 3) < 0) {
    perror("listen");
    exit(EXIT_FAILURE);
}

printf("Server listening on port %d...\n", PORT);

// Accept incoming connections
while ((new_socket = accept(server_fd, (struct sockaddr *)&client_addr, (socklen_t*)&addrlen))) {
    pthread_t thread;
    int *new_sock = malloc(1);
    *new_sock = new_socket;
    
    if (pthread_create(&thread, NULL, connection_handler, (void*)new_sock) < 0) {
        perror("could not create thread");
        return 1;
    }
    
    // Now join the thread, so that we don't terminate before the thread
    pthread_join(thread, NULL);
}

if (new_socket < 0) {
    perror("accept failed");
    return 1;
}

return 0;

}

void *connection_handler(void *socket_desc) {
// Get the socket descriptor
int sock = (int)socket_desc;
int read_size;
char client_message[1024];
char response[1024] = “HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n

Hello, World!

”; 

// Receive a message from client
read_size = recv(sock, client_message, 1024, 0);
if (read_size > 0) {
    // Send the message back to client
    write(sock, response, strlen(response));
}

free(socket_desc);
close(sock);
pthread_exit(NULL);

}

post请求处理

void *connection_handler(void *socket_desc) {
// Get the socket descriptor
int sock = (int)socket_desc;
int read_size;
char client_message[1024];
char response[1024];

// Receive a message from client
read_size = recv(sock, client_message, 1024, 0);
if (read_size > 0) {
    // Parse HTTP request to get method and URI
    char method[10], uri[50];
    sscanf(client_message, "%s %s", method, uri);
    
    // Check if it's a POST request
    if (strcmp(method, "POST") == 0) {
        // Find where the POST data begins
        char *data_start = strstr(client_message, "\r\n\r\n");
        if (data_start) {
            // Move to actual data
            data_start += 4;
            
            // Example: Parse POST data (here assuming it's form-urlencoded)
            char post_data[1024];
            sscanf(data_start, "%s", post_data);
            
            // Generate a response based on received data
            sprintf(response, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<html><body><h1>Hello, World! This is a POST request</h1><p>Received data: %s</p></body></html>", post_data);
        } else {
            // Malformed POST request (no data found)
            sprintf(response, "HTTP/1.1 400 Bad Request\r\nContent-Type: text/plain\r\n\r\nBad Request");
        }
    } else {
        // Handle other HTTP methods (not implemented in this example)
        sprintf(response, "HTTP/1.1 405 Method Not Allowed\r\nContent-Type: text/plain\r\n\r\nMethod Not Allowed");
    }
    
    // Send the message back to client
    write(sock, response, strlen(response));
}

free(socket_desc);
close(sock);
pthread_exit(NULL);

}

传输图像

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

#define PORT 8080
#define BUFFER_SIZE 1024

void send_image(int client_socket, const char *filename) {
FILE *fp = fopen(filename, “rb”);
if (fp == NULL) {
perror(“Error opening file”);
return;
}

fseek(fp, 0, SEEK_END);
long file_size = ftell(fp);
rewind(fp);

// 构建 HTTP 头部
char header[BUFFER_SIZE];
snprintf(header, sizeof(header),
    "HTTP/1.1 200 OK\r\n"
    "Content-Type: image/jpeg\r\n"
    "Content-Length: %ld\r\n\r\n", file_size);

// 发送 HTTP 头部
send(client_socket, header, strlen(header), 0);

// 发送图像数据
char buffer[BUFFER_SIZE];
size_t bytes_read;
while ((bytes_read = fread(buffer, 1, BUFFER_SIZE, fp)) > 0) {
    send(client_socket, buffer, bytes_read, 0);
}

fclose(fp);

}

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int addrlen = sizeof(address);

// 创建 socket
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
}

address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// 绑定地址和端口
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
    perror("Bind failed");
    exit(EXIT_FAILURE);
}

// 监听连接
if (listen(server_fd, 10) < 0) {
    perror("Listen failed");
    exit(EXIT_FAILURE);
}

printf("Server listening on port %d\n", PORT);

while (1) {
    // 接受连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
        perror("Accept failed");
        exit(EXIT_FAILURE);
    }

    // 接收客户端请求
    char buffer[BUFFER_SIZE] = {0};
    read(new_socket, buffer, BUFFER_SIZE);

    // 提取请求中的文件名
    char *filename = "example.jpg"; // 修改为实际的图片文件名
    printf("Requested file: %s\n", filename);

    // 发送图片
    send_image(new_socket, filename);

    // 关闭连接
    close(new_socket);
}

return 0;

}

使用文件描述符

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>

#define PORT 8080
#define BUFFER_SIZE 1024

void send_image(int client_fd, const char *filename) {
int file_fd = open(filename, O_RDONLY);
if (file_fd < 0) {
perror(“Error opening file”);
return;
}

// 获取文件大小
off_t file_size = lseek(file_fd, 0, SEEK_END);
lseek(file_fd, 0, SEEK_SET);

// 构建 HTTP 头部
char header[BUFFER_SIZE];
snprintf(header, sizeof(header),
    "HTTP/1.1 200 OK\r\n"
    "Content-Type: image/jpeg\r\n"
    "Content-Length: %ld\r\n\r\n", (long)file_size);

// 发送 HTTP 头部
write(client_fd, header, strlen(header));

// 发送图像数据
char buffer[BUFFER_SIZE];
ssize_t bytes_read;
while ((bytes_read = read(file_fd, buffer, BUFFER_SIZE)) > 0) {
    write(client_fd, buffer, bytes_read);
}

close(file_fd);

}

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int addrlen = sizeof(address);

// 创建 socket
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
}

address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);

// 绑定地址和端口
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
    perror("Bind failed");
    exit(EXIT_FAILURE);
}

// 监听连接
if (listen(server_fd, 10) < 0) {
    perror("Listen failed");
    exit(EXIT_FAILURE);
}

printf("Server listening on port %d\n", PORT);

while (1) {
    // 接受连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
        perror("Accept failed");
        exit(EXIT_FAILURE);
    }

    // 接收客户端请求
    char buffer[BUFFER_SIZE] = {0};
    read(new_socket, buffer, BUFFER_SIZE);

    // 提取请求中的文件名
    char *filename = "example.jpg"; // 修改为实际的图片文件名
    printf("Requested file: %s\n", filename);

    // 发送图片
    send_image(new_socket, filename);

    // 关闭连接
    close(new_socket);
}

return 0;

}

我在路易斯安那
关注
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
Linux多线程概念及实现
向未来❀去探索 的博客
07-01 1986
Linux多线程概念及实现
linux多线程服务器编程
11-16
这是在公司同事那里看到的一本书,写的是linux多线程服务器编程
linux下多线程服务器,Linux系统编程—多线程服务器
weixin_39722375的博客
05-07 247
与多进程相同，采用多线程也能实现并发服务器，并且由于线程的系统开销小、切换时间短，对于需处理大量客户的服务器而言有更大优势。实现多线程并发服务器的基本过程是：当连接建立后，服务器调用pthread_create()函数产生新的线程，由新线程处理客户请求，同时主线程等待另一客户的连接请求。其结构比多进程服务器更简单。因为所有的线程共享打开的描述符，主线程不能关闭连接套接字，新线程也不能关闭监听套接字...
一个简单的Linux多线程服务器
dblinux
11-01 343
Linux多线程 1. Linux多线程并发服务器模型 ​ 在Linux多线程服务端编程时，首先还是之前的三步走????（创建socket、bind绑定地址与端口号、listen设置最大监听上限）。重要的是线程回调函数和循环里面的逻辑。下面给出该步骤： 2. 线程知识回顾 线程是程序中完成一个独立任务的完整执行序列，即一个可调度的实体。 线程创建????‍♀： #include <pthread.h> int pthread_create(pthread_t* thread, con
Linux并发服务器之多线程服务器
leikun153的博客
04-18 725
一：服务器模型一般分为两种1：循环服务器：服务器同一时刻只能响应一个客户端的请求2：并发服务器：服务器在同一时刻可以响应多个客户端的请求二：并发服务器的三中实现方式1：多进程并发服务器是指TCP连接后，每一个客户机的请求并不由服务器直接处理，而是由服务器创建一个子进程来处理2：多线程并发服务器多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程...
Linux服务器多线程编程
masterfuck的博客
03-24 1335
Linux多线程服务器开发笔记 第三章-----多线程服务器适用场合与常用编程模型 目录Linux多线程服务器开发笔记前言一、进程与线程二、使用步骤1.引入库2.读入数据总结 前言 本文记录了我阅读《Linux多线程编程》的一些笔记 一、进程与线程 进程是操作系统里的一个非常重要的概念，它是CPU资源分配的基本单位。而线程则是在进程的基础之上衍生而来，它是CPU资源调度的的基本单位。属于同一个进程的多个线程通常可以共享地址空间，从而可以高效的共享数据。而多个进程只能共享代码段，但不能共享数据。 二、使
linux多进程和网络编程---ftp服务器实战
06-12
基于linux编程龙书，Apue和UNP深入浅出讲解原理: 文件读写效率，多进程与僵尸，信号合并，多线程读写锁同步，高并发服务端，select多路复用并以3000行ftp开源服务器剖析，巩固知识 linux基础编程linux网络编程ftp...
linux多线程服务器编程pdf
最新发布
07-01
《Linux多线程服务器编程PDF》是一本关于在Linux系统下进行多线程服务器编程的电子书。它主要讲解了如何利用Linux的多线程技术来搭建高性能的服务器应用程序。 这本书首先介绍了多线程编程的基本概念和原理，包括...
LINUX下的一个多线程的服务器和客户端的网络传输程序
12-04
LINUX下的一个多线程的服务器和客户端的网络传输程序，初学者可以作为参考。 LINUX下的一个多线程的服务器和客户端的网络传输程序，初学者可以作为参考
linux多线程并发服务器
e891377的专栏
08-21 357
linux多线程并发服务器 此为多线程并发服务器，多进程版。 #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <sys/types.h> #include <string.h> #include <sys/socket.h> #include <arpa/inet.h> #include <ctype.h> #include
Linux网络编程（三）——多线程并发服务器
分享一些自己的学习心得体会和总结！
05-30 619
1.程序、进程和线程 二进制程序（binaries）是指保存在存储介质上的程序，以给定操作系统和计算机体系结构可访问的格式编译生成，可以运行但尚未开始。 进程（processes）是操作系统对运行的二进制程序的抽象，包括:加载的二进制程序、虚拟内存、内核资源如打开的文件、关联的用户等。 线程（threads）是进程内的执行单元，具体包括:虚拟处理器、堆栈、程序状态。换句话说，进程是正在运行在二进制程序，线程是操作系统调度器可以调度的最小执行单元。 一个进程包含一个或多个线程。如果一个进程只包含一个线程,则该
Linux - 多进程、线程服务器实现
m0_60154918的博客
08-18 428
缓存 IO又被称作标准 IO，大多数文件系统的默认 IO 操作都是缓存 IO。在 Linux 的缓存 IO 机制中，操作系统会将 IO 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。......
Linux编程基础 8.2：多线程并发服务器
爱学习爱运动的专栏
05-16 299
2 多线程并发服务器 每个进程可打开的文件描述符数量有限，且进程占用资源较多，系统中进程的数量又受到内存大小的限制，为保证服务器效率，降低服务器消耗，可利用多线程机制搭建并发服务器。 【案例2】搭建多线程并发服务器。 服务器端：接收多个客户端的数据，并将接收到的数据转为大写，写回客户端； 客户端：向服务器发送数据，并将服务器返回的数据打印到终端。 pthreadServer.c #include <stdio.h> #include <string.h> #include &lt
Linux系统编程之多线程并发服务器简单实现
qq_45164331的博客
11-07 226
服务端 #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<fcntl.h> #include<string.h> #include<pthread.h> #include<sys/socket.h> #include<arpa/inet.h> #define IP "127.0.0.1" #define PORT 7777 int c
赖勇浩：推荐《Linux 多线程服务器端编程》
923723914
08-28 627
推荐《Linux 多线程服务器端编程》 赖勇浩（http://laiyonghao.com）最近，有一位朋友因为工作需要，需要从网游的客户端编程转向服务器端编程，找我推荐一本书。我推荐了《Linux 多线程服务器端编程——使用 muduo C++ 网络库》给他，他在网上书店看了以后问我为什么推荐这么厚一本书给他，正好这本书我已经早就看完了，一直也想写篇“书评”，就在这里多扯几句。其实实在算不上书...
Linux并发服务器编程之多线程并发服务器
年轻人，潜力无限！
12-21 7561
上一篇文章使用fork函数实现了多进程并发服务器，但是也提到了一些问题： fork是昂贵的。fork时需要复制父进程的所有资源，包括内存映象、描述字等； 目前的实现使用了一种写时拷贝（copy-on-write）技术，可有效避免昂贵的复制问题，但fork仍然是昂贵的; fork子进程后，父子进程间、兄弟进程间的通信需要进程间通信IPC机制，给通信带来了困难； 多进程在一定程度上仍然不能有效地利用系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值