//命令lsof -i:5999
//简单服务器
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define MYPORT 5999
#define BACKLOG 10
int main(){
int sock_fd, new_fd;
struct sockaddr_in my_addr, their_addr;
int sin_size;
if((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(MYPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 8);
if(bind(sock_fd, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) == -1){
perror("bind");
exit(1);
}
if(listen(sock_fd, BACKLOG) == -1){
perror("listen");
exit(1);
}
while(1){
sin_size = sizeof(struct sockaddr_in);
if((new_fd = accept(sock_fd, (struct sockaddr *)&their_addr, &sin_size)) == -1){
perror("accept");
continue;
}
printf("server.got connection from %s\n",inet_ntoa(their_addr.sin_addr));
if(!fork()){
if(send(new_fd, "Hello,world!\n", 14, 0) == -1){
perror("send");
close(new_fd);
exit(0);
}
}
while(waitpid(-1, NULL, WNOHANG) > 0);
}
}
//简单客户端
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 5999
#define MAXDATASIZE 100
int main(int argc, char *argv[]){
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr;
if(argc != 2){
fprintf(stderr, "usage: client hostname\n");
exit(1);
}
if((he = gethostbyname(argv[1])) == NULL){
perror("gethostbyname");
exit(1);
}
// printf();
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(PORT);
//their_addr.sin_addr = *((struct in_addr*)he->h_addr);
their_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
bzero(&(their_addr.sin_zero), 8);
if(connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1){
perror("connect");
exit(1);
}
if((numbytes = recv(sockfd, buf, MAXDATASIZE, 0)) == -1){
perror("recv");
exit(1);
}
buf[numbytes] = '\0';
printf("Received: %s", buf);
close(sockfd);
return 0;
}
//epoll 服务器端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/wait.h>
#define SERVPORT 5999
#define BACKLOG 10 //最大同时连接请求数
void setnonblocking(int sock){
int opts;
opts = fcntl(sock, F_GETFL);
if(opts < 0){
perror("fcntl(sock, GETFL)");
exit(1);
}
opts = opts | O_NONBLOCK;
if(fcntl(sock, F_SETFL, opts) < 0){
perror("fcntl(sock, SETFL, opts)");
exit(1);
}
}
void do_use_fd(int client_fd){
char msg[50];
const char str[] = "God bless you!\n";
recv(client_fd, msg, 50, 0);
printf("get from client msg %s\n", msg);
if(send(client_fd, str, sizeof(str), 0) == -1)
perror("send");
close(client_fd);
}
int main(){
int sockfd;
struct sockaddr_in my_addr;
struct sockaddr_in their_addr;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(SERVPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 8);
if(bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1){
perror("bind");
exit(1);
}
if(listen(sockfd, BACKLOG) == -1){
perror("listen");
exit(1);
}
size_t sin_size = sizeof(struct sockaddr_in);
#define MAX_EVENTS 10
struct epoll_event ev, events[MAX_EVENTS];
int conn_sock, nfds, epollfd;
epollfd = epoll_create(10);
if(epollfd == -1){
perror("epoll_create");
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = sockfd;
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1){
perror("epoll_ctl: sockfd");
exit(EXIT_FAILURE);
}
for(;;){
nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
if(nfds == -1){
perror("epoll_wait");
exit(EXIT_FAILURE);
}
int i;
for(i = 0; i < nfds; ++i){
if(events[i].data.fd == sockfd){
conn_sock = accept(sockfd,
(struct sockaddr *)&their_addr, &sin_size);
if(conn_sock == -1){
perror("accept");
exit(EXIT_FAILURE);
}
setnonblocking(conn_sock);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = conn_sock;
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock,
&ev) == -1){
perror("epoll_ctl: conn_sock");
exit(EXIT_FAILURE);
}
}else{
do_use_fd(events[i].data.fd);
}
}
}
}
//epoll 客户端
#include <stdio.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <string.h>
#define PORT 5999
#define MSG 50
int main(){
int sockfd;
char msg[MSG];
struct sockaddr_in their_addr;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket() failed");
exit(1);
}
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(PORT);
their_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
bzero(&their_addr.sin_zero, 8);
if(connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1){
perror("connect error");
exit(1);
}
send(sockfd, "HELLO", 20, 0);
recv(sockfd, msg, MSG, 0);
printf("%s\n", msg);
close(sockfd);
}
//管道
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define MAXMSG 0xff
int main(){
int fd_req[2];/*声明了两个管道描述符，一个用来发询问信息*/
int fd_ans[2];/* 一个用来回答 */
pid_t pid;
char msg[MAXMSG];
if(pipe(fd_req) < 0 || pipe(fd_ans) < 0){
perror("init pipe fault...\n");
return -1;
}
if((pid = fork()) < 0){
perror("init fork fault...\n");
}
if(pid > 0){//father process
close(fd_req[1]);
close(fd_ans[0]);
int res, ask;
printf("Enter a number between 1-1000: ");
scanf("%d", &res); //输入答案
write(fd_ans[1], "start", MAXMSG); //给子进程解锁
while(1){
read(fd_req[0], msg, MAXMSG);
if(strcmp(msg, "end") == 0){ //结束标识，则结束。
close(fd_req[0]);
close(fd_ans[1]);
return 0;
}
ask = atoi(msg);
if(res > ask)
write(fd_ans[1], "yes", MAXMSG);
else
write(fd_ans[1], "no", MAXMSG);
}
}else{
int from = 0, to = 1024, mid;
read(fd_ans[0], msg, MAXMSG); //首先阻塞子进程，直到父进程发消息
while(1){
mid = (from + to) / 2;
sprintf(msg, "%d", mid);
write(fd_req[1], msg, MAXMSG); //询问
printf("Is the number bigger than %d(yes/no)?\n", mid);
read(fd_ans[0], msg, MAXMSG); //回答
printf("%s\n", msg);
if(strcmp(msg, "yes") == 0)
from = mid;
else
to = mid;
if(from + 1 == to){
printf("I have succeeded in guessing your number! ans = %d\n", to);
write(fd_req[1], "end", MAXMSG);
return ;
}
}
}
}
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>
#include <stdlib.h>
#define TIME1 200
#define TIME2 199
int apple_num(int from, int to){
if(to >= from)
return to - from;
return to + 6 - from;
}
sem_t sem_apple, sem_space;
pthread_mutex_t producer_mutex, customer_mutex;
int from = 0, to = 0;
void * producer(void *args){
int time = TIME1;
while(time--){
pthread_mutex_lock(&producer_mutex);
sem_wait(&sem_space);
to = (to + 1) % 6;
printf("生产一个，当前苹果数目%d个\n", apple_num(from, to));
sem_post(&sem_apple);
pthread_mutex_unlock(&producer_mutex);
}
}
void * customer(void *args){
int time = TIME2;
while(time--){
pthread_mutex_lock(&customer_mutex);
sem_wait(&sem_apple);
from = (from + 1) % 6;
printf("消费一个，当前苹果数目%d个\n", apple_num(from, to));
sem_post(&sem_space);
pthread_mutex_unlock(&customer_mutex);
}
}
int main(){
pthread_t id1[3], id2[3];
//int ret1, ret2;
sem_init(&sem_apple, 0, 0);
sem_init(&sem_space, 0, 5);
pthread_mutex_init(&producer_mutex, NULL);
pthread_mutex_init(&customer_mutex, NULL);
int i;
for(i = 0; i < 3; i++){
if(pthread_create(&id1[i], NULL, (void *)producer, NULL) != 0){
perror("pthread_create()");
exit(1);
}
if(pthread_create(&id2[i], NULL, (void *)customer, NULL) != 0){
perror("pthread_create()");
exit(1);
}
}
for(i = 0; i < 3; i++){
pthread_join(id1[i], NULL);
pthread_join(id2[i], NULL);
}
sem_destroy(&sem_apple);
sem_destroy(&sem_space);
return 0;
}
分享到：
相关推荐
在实现Linux串口通信时，我们通常会用到几个关键的命令行工具，例如`minicom`、`screen`或自编写的脚本程序。这些工具允许我们配置串口参数，如波特率、数据位、停止位、校验位，并进行读写操作。 以标题中提到的...
**实验四：Linux下进程管道通信** 实验的目标是理解和掌握Linux操作系统中进程间通信的管道机制，通过系统调用pipe()实现数据交换。管道是一种特殊类型的文件，它允许相关进程之间进行单向通信。在这个实验中，我们...
在本例中，Windows 10作为上位机，通过TCP/IP与ARM Linux设备通信。 4. **TCP/IP网络通信**： 实现两个系统间的TCP/IP通信，需要创建服务器和客户端。服务器等待客户端的连接请求，而客户端则主动发起连接。在本...
Linux环境下进行ARM/单片机串口通信设计涉及多个方面，包括Linux系统下的串口操作、ARM微处理器的串口通信配置、单片机串口通信设计、以及两者之间硬件连接和软件通信流程。以下将详细阐述这些知识点。 首先，Linux...
### Linux网络通信详解 #### 一、引言 随着互联网的发展和普及，网络通信成为现代生活中不可或缺的一部分。作为开源操作系统的佼佼者，Linux凭借其强大的网络功能，在服务器领域占据了主导地位。本章节将深入探讨...
【Linux网络通信高级编程Socket】章节主要探讨了在Linux环境下如何进行高级的网络通信编程，特别是使用Socket进行TCP/IP通信。Socket是网络编程的核心概念，它代表了一个通信端点，结合IP地址和端口号，用于标识网络...
下面以 TCP 为例，介绍几个基本的 socket 接口函数： 1. socket() 函数 int socket(int domain, int type, int protocol); socket 函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而 ...
本主题主要探讨的是如何使用C语言在Linux下实现基于socket的客户端和服务端通信，并且采用多线程技术，使得客户端和服务器可以相互发送消息而无需等待对方回应。 首先，我们来理解一下基本的socket通信流程。创建...
《LINUX设备驱动程序例》第三版是一本深入浅出介绍Linux设备驱动开发的经典书籍，书中包含了大量的实例，帮助读者理解和实践Linux驱动程序的编写。下面将详细探讨Linux设备驱动程序的一些核心概念、分类以及如何编写...
本文主要探讨了如何在基于ARM架构的Linux系统中设计和实现异步串行通信，特别以三星公司的$3C2410X处理器为例，阐述了串行通信的硬件电路和软件技术。 1. 引言 嵌入式系统是信息技术的重要组成部分，特别是在网络...
Linux DHCP 网络故障排除一例 本资源介绍了 Linux 操作系统中 DHCP 网络故障排除的一例，解决了 Linux 客户机无法取得 IP 地址的问题。通过分析dhcpd 服务器和 DHCP 客户机的交互过程，发现问题出在 Linux 客户机...
总结来说，实现Linux上的Modbus TCP协议涉及理解Modbus协议结构、使用TCP套接字进行通信以及利用libmodbus或其他相关库提供的API。通过这些步骤，你可以创建能够与Modbus设备交互的应用程序，无论是作为客户端从设备...
在Linux操作系统中，进程间的通信（IPC，Inter-Process Communication）是实现不同进程协同工作的重要机制。本示例着重探讨了一种基础的IPC形式——匿名管道。匿名管道是一种半双工（即数据只能单向流动）的数据通信...
本篇将基于提供的"Linux网络编程小例"进行深入探讨。 标题"Linux网络编程小例"暗示了我们将讨论如何在Linux操作系统上编写网络应用程序。Linux提供了一系列API，如套接字（socket）接口，用于实现TCP/IP协议栈上的...
以dterm-0.3为例，这是一个轻量级的Linux串口终端工具。安装dterm后，用户可以通过图形界面配置串口参数，并实时查看和发送数据。其使用方法通常包括以下步骤： 1. **安装dterm**：在终端中输入`sudo apt-get ...
本文以 AT24C02 为例，详细介绍了 IIC 总线的通信方式，并着重介绍了基于 ARM-Linux 的 IIC 总线设备的驱动编写。 IIC 总线的应用非常广泛，例如在智能家电、汽车电子、医疗电子等领域都有广泛的应用。同时，IIC ...
本篇文章将深入探讨Linux下的管道通信，并以C语言为例，解析如何创建和使用管道。 首先，管道的特性是半双工通信，即数据只能在一个方向上流动，不能同时双向传输。它由一个内核维护的缓冲区组成，两个进程通过共享...
本文将详细介绍Linux环境下ARM处理器（以S3C2440为例）与C8051Fxxx系列单片机进行串口通信的设计方法。 首先，串口通信的基本原理是通过串行数据线（TXD和RXD）进行数据的发送和接收，通常还包含一个共同的地线...
### Linux进程间管道通信的研究 #### 一、引言 对于多用户、多任务的操作系统而言，进程间的通信（Inter-Process Communication, IPC）是非常重要的组成部分。它为系统的有序运作奠定了基础。Linux作为一种开放源...