计算机网络（3） --- 网络套接字TCP

计算机网络（2） --- 网络套接字UDP_哈里沃克的博客-CSDN博客https://blog.csdn.net/m0_63488627/article/details/131977544?spm=1001.2014.3001.5501

目录

1.TCP

1.服务端接口介绍

1.listen状态

2.accept获取链接

2.客户端接口介绍

2.TCP的服务器和客户端接口实现

1.服务端

1.成员函数

2.接口

start()实现方式

1.单一执行流

2.多进程

3.多线程

4.线程池

3.main函数

2.客户端

1.成员函数

2.接口

3.mian函数

3.守护进程化

1.守护进程

2.代码

1.TCP

回顾一下UDP套接字，实现很简单，只需要初始化然后再send即可。但是TCP更加复杂

1.服务端接口介绍

1.listen状态

listen状态适用于获取先链接的，第二个参数不能填太大的int类型数据。

2.accept获取链接

 服务器只有先accept获取新链接(客户端传来的套接字)，才能接受到套接字。

1.调用成功返回一个文件描述符， 失败返回-1。这个返回值其实对应的是一个套接字。

2.第一个sockfd其实是接收用的套接字，它不参与到具体的操作内；而返回值返回的套接字才是客户端返回的套接字，这个套接字是用于处理的。

3.由于tcp是面向字节流的，所以接受到的套接字就可以使用read和write进行操作了

4.如果该套接字使用完毕，一定要释放(close)套接字。因为文件描述符的本质是数组，而数组有一定的上限，我们不能只入而不释放，如果不释放会出现文件描述符泄漏。

2.客户端接口介绍

1.connect：发起链接

链接对应服务端的ip和port，表示自己要链接哪个服务端

2.TCP的服务器和客户端接口实现

1.服务端

namespace Server
{enum{USAGE_ERR = 1,SOCKET_ERR,BIND_ERR,LISTEN_ERR,OPEN_ERR};static const uint16_t gport = 8080;static const int gbacklog = 5;class tcpServer{public:tcpServer(const uint16_t &port = gport): _listensock(-1), _port(port){}void initServer(){// 1.创建_listensock = socket(AF_INET, SOCK_STREAM, 0);if (_listensock < 0){logMessage(FATAL, "create listensock error");exit(SOCKET_ERR);}logMessage(NORMAL, "create listensock success");// 2.bindstruct 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;if (bind(_listensock, (struct sockaddr *)&local, sizeof local) < 0){logMessage(FATAL, "bind error");exit(BIND_ERR);}logMessage(NORMAL, "bind listensock success");// 3.设置socket，为监听状态if (listen(_listensock, gbacklog)){logMessage(FATAL, "listen error");exit(LISTEN_ERR);}logMessage(NORMAL, "listen listensock success");}void start(){for (;;){// 单线程版，只能有一个执行流，其他的无法进入执行，因为serviceIO死循环// 1.sever获取新链接struct sockaddr_in peer;socklen_t len = sizeof peer;int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){logMessage(ERROR, "accept error, next"); // accept失败不影响整体的代码，继续访问即可continue;}logMessage(NORMAL, "accept a new link success");std::cout << "sock: " << sock << std::endl;// sock是面向字节流的，后续全部都是文件操作serviceIO(sock);close(sock); //不释放会出现文件描述符泄漏}}void serviceIO(int sock){char buffer[1024];while (true){ssize_t n = read(sock, buffer, sizeof(buffer) - 1);if (n > 0){buffer[n] = 0;std::cout << "recv message: " << buffer << std::endl;std::string outbuffer = buffer;outbuffer += "server[echo]";write(sock, outbuffer.c_str(), outbuffer.size());}else if (n == 0){// 代表client退出logMessage(NORMAL, "client quit,me too");break;}}}~tcpServer(){}private:uint16_t _port;int _listensock; // 不是用来通信的，而是用于监听链接的};
}

1.成员函数

uint16_t _port：端口号

int _listensock：监听套接字

2.接口

1.initServer()创建套接字，先初始化监听套接字；生成对应的监听套接字；随后将当前的IP设置为任意IP，并且设置port最后绑定(bind)起来；随后还需要listen监听套接字

2.start()先定义新套接字，accept获取新套接字，执行套接字传输的任务。

start()实现方式

1.单一执行流
        void start(){for (;;){// 1.sever获取新链接struct sockaddr_in peer;socklen_t len = sizeof peer;int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){logMessage(ERROR, "accept error, next"); // accept失败不影响整体的代码，继续访问即可continue;}logMessage(NORMAL, "accept a new link success");std::cout << "sock: " << sock << std::endl;// sock是面向字节流的，后续全部都是文件操作serviceIO(sock);close(sock); //不释放会出现文件描述符泄漏}}

这样的缺点很明显：只有一个执行流操作服务端，也就意味着客户端只有一个能链接服务端。而且serviceIO()是一个死循环函数，那么只有客户端主动退出才能让其他客户端链接。这是串行的执行逻辑

2.多进程
1.信号版void start(){signal(SIGCHLD, SIG_IGN);for (;;){// 1.sever获取新链接struct sockaddr_in peer;socklen_t len = sizeof peer;int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){logMessage(ERROR, "accept error, next"); // accept失败不影响整体的代码，继续访问即可continue;}logMessage(NORMAL, "accept a new link success");std::cout << "sock: " << sock << std::endl;// 多进程pid_t id = fork();if (id == 0){// childclose(_listensock);serviceIO(sock);close(sock);exit(0);}close(sock);}}

1.直接忽略子进程阻塞的状态，这样操作系统会自动回收

2.只要子进程自动回收，那么父进程就不需要等待，直接不断的按照需求新建子进程，而子进程执行结束不需要管理也不会有内存泄漏问题

3.在父进程处close(sock)的做法是为了不让文件描述符泄漏，子进程的close不影响父进程，如果父进程不弄，子进程把自己的套接字关闭不代表父进程的套接字也被关闭了

2.waitpid版void start(){for (;;){// 1.sever获取新链接struct sockaddr_in peer;socklen_t len = sizeof peer;int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){logMessage(ERROR, "accept error, next"); // accept失败不影响整体的代码，继续访问即可continue;}logMessage(NORMAL, "accept a new link success");std::cout << "sock: " << sock << std::endl;// 多进程pid_t id = fork();if (id == 0){// childclose(_listensock);if (fork() > 0)exit;// 孙子进程变为孤儿进程serviceIO(sock);close(sock);exit(0);}close(sock);// fatherpid_t ret = waitpid(id, nullptr, 0); //子进程进去直接死亡回收，不需要管理if (ret > 0)std::cout << "wait success: " << ret << std::endl;}}

1.父进程先非阻塞等待

2.子进程中创建孙子进程，孙子进程执行接收的文件，子进程直接退出，让父进程回收。此时孙子进程变成孤儿进程托付给操作系统，操作系统管理孙子进程的结束。

多进程展现的问题就是消费太多资源，本来一个执行流能解决的事情却创造了调度执行流的基本单位进程来实现，而且拷贝需要时间，成本过大。

3.多线程
    class ThreadData{public:ThreadData(tcpServer *self, int sock): _self(self), _sock(sock){}public:tcpServer *_self;int _sock;};void start(){for (;;){// 1.sever获取新链接struct sockaddr_in peer;socklen_t len = sizeof peer;int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){logMessage(ERROR, "accept error, next"); // accept失败不影响整体的代码，继续访问即可continue;}logMessage(NORMAL, "accept a new link success");std::cout << "sock: " << sock << std::endl;// 多线程pthread_t tid;ThreadData *td = new ThreadData(this, sock);pthread_create(&tid, nullptr, threadRoutine, td);}}static void *threadRoutine(void *args){pthread_detach(pthread_self());ThreadData *td = static_cast<ThreadData *>(args);td->_self->serviceIO(td->_sock);delete td;close(td->_sock);return nullptr;}

1.创造线程，让子线程进行接收执行。当然为了不需要串行执行，在threadRoutine()中，优先将当前线程进行线程分离。这样主线程就不需要回收子线程，子线程结束操作系统就会自动回收。

2.执行后需要将当前的文件描述符回收，由于函数是线程的公共资源，所以threadRoutine内就能影响到。

4.线程池
//线程池
using namespace ThreadNs;const int gnum = 10;template <class T>
class ThreadPool;template <class T>
class ThreadData
{
public:ThreadData(ThreadPool<T> *tp, const std::string &n): threadpool(tp), name(n){}public:ThreadPool<T> *threadpool;std::string name;
};template <class T>
class ThreadPool
{
private:static void *handlerTask(void *args){ThreadData<T> *td = static_cast<ThreadData<T> *>(args);while (true){T t;{// td->threadpool->lockQueue();LockGuard lockguard(td->threadpool->mutex());while (td->threadpool->isQueueEmpty()){td->threadpool->threadWait();}t = td->threadpool->pop();}// td->threadpool->unlockQueue();std::cout << td->name << "处理完了任务: " << t.toTaskString() << "并处理完成，结果是： " << t();}return nullptr;}ThreadPool(const int &_num = gnum): _num(gnum){pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_cond, nullptr);for (int i = 0; i < _num; i++){_threads.push_back(new Thread());}}void operator=(const ThreadPool &) = delete;ThreadPool(const ThreadPool &) = delete;public:static ThreadPool<T> *getInstance(){if (_tp == nullptr){_singleton_lock.lock();if (_tp == nullptr){_tp = new ThreadPool<Task>();}_singleton_lock.unlock();}return _tp;}// void lockQueue()// {//     pthread_mutex_lock(&_mutex);// }// void unlockQueue()// {//     pthread_mutex_unlock(&_mutex);// }bool isQueueEmpty(){return _task_queue.empty();}void threadWait(){pthread_cond_wait(&_cond, &_mutex);}T pop(){T t = _task_queue.front();_task_queue.pop();return t;}pthread_mutex_t *mutex(){return &_mutex;}public:void run(){for (const auto &t : _threads){ThreadData<T> *td = new ThreadData<T>(this, t->threadname());t->start(handlerTask, td);std::cout << t->threadname() << " start ..." << std::endl;}}void push(const T &in){// pthread_mutex_lock(&_mutex);LockGuard lockguard(&_mutex);_task_queue.push(in);pthread_cond_signal(&_cond);// pthread_mutex_unlock(&_mutex);}~ThreadPool(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_cond);for (const auto &t : _threads)delete t;}private:int _num;std::vector<Thread *> _threads;std::queue<T> _task_queue;pthread_mutex_t _mutex;pthread_cond_t _cond;static ThreadPool<T> *_tp;static std::mutex _singleton_lock;
};template <class T>
ThreadPool<T> *ThreadPool<T>::_tp = nullptr;
static std::mutex _singleton_lock;
/void start(){// 线程池初始化ThreadPool<Task>::getInstance()->run();for (;;){// 1.sever获取新链接struct sockaddr_in peer;socklen_t len = sizeof peer;int sock = accept(_listensock, (struct sockaddr *)&peer, &len);if (sock < 0){logMessage(ERROR, "accept error, next"); // accept失败不影响整体的代码，继续访问即可continue;}logMessage(NORMAL, "accept a new link success");std::cout << "sock: " << sock << std::endl;// 4.线程池ThreadPool<Task>::getInstance()->push(Task(sock, serviceIO));}}

3.main函数

using namespace std;
using namespace Server;static void Usage(string proc)
{cout << "Usage:\n\t" << proc << " local_ip local_port\n\n";
}int main(int argc, char *argv[])
{if (argc != 2){Usage(argv[0]);exit(USAGE_ERR);}uint16_t port = atoi(argv[1]);std::unique_ptr<tcpServer> tsvr(new tcpServer(port));tsvr->initServer();tsvr->start();return 0;
}

1. 一旦启动，就会进入LISTEN状态

2.客户端

#define NUM 1024namespace Client
{class tcpClient{public:tcpClient(const std::string &serverip, const uint16_t &serverport): _serverip(serverip), _serverport(serverport), _sock(-1){}void initClient(){// 1.创建socket_sock = socket(AF_INET, SOCK_STREAM, 0);if (_sock < 0){std::cerr << "socket error: " << errno << " : " << strerror(errno) << std::endl;exit(2);}// 2.client要不要bind[必须要的]，client要不要显示的bind，不需要// 3.客户端不需要listen// 4.也不需要accept}void start(){// 5.要发起链接struct sockaddr_in server;memset(&server, 0, sizeof server);server.sin_family = AF_INET;server.sin_port = htons(_serverport);server.sin_addr.s_addr = inet_addr(_serverip.c_str());if (connect(_sock, (struct sockaddr *)&server, sizeof server) != 0){std::cerr << "connect error: " << errno << " : " << strerror(errno) << std::endl;}else{std::string msg;while (true){std::cout << "Enter# ";std::getline(cin, msg);write(_sock, msg.c_str(), msg.size());char buffer[NUM];int n = read(_sock, buffer, sizeof(buffer) - 1);if (n > 0){buffer[n] = 0;std::cout << "server回显的信息: " << buffer << std::endl;}else{break;}}}}~tcpClient(){if (_sock >= 0)close(_sock);}private:int _sock;std::string _serverip;uint16_t _serverport;};
}

1.成员函数

int _sock：套接字
std::string _serverip：server的IP地址
uint16_t _serverport：server发PORT

2.接口

3.mian函数

static void Usage(string proc)
{cout << "Usage:\n\t" << proc << " server_ip server_port\n\n";
}int main(int argc, char *argv[])
{if (argc != 3){Usage(argv[0]);exit(1);}uint16_t serverport = atoi(argv[2]);std::string serverip = argv[1];std::unique_ptr<tcpClient> tcli(new tcpClient(serverip, serverport));tcli->initClient();tcli->start();return 0;
}

在同一个服务器运行客户端和服务端

1.ESTABLISHED：指的是客户端被服务端所接收了

2.tcp的Server查到的是服务器的链接

3.tcp的Client查到的是客户端的链接

4.两端都是全双工的

3.守护进程化

1.守护进程

1.xshell在操作系统下会生成一个会话，此时bash充当前台任务，其他都是后台任务

2.前台任务有且只能有一个，而后台任务能允许有多个

3.所有的作业可以前后台转换。先fg转换，再ctrl+Z切换后台暂停，最后bg使得暂停任务重新开始

4.这些任务可能受到用户的登录和注销的影响的，我们需要将作业自称独立会话，和终端设备无关，这样的进程为守护进程

1.setsid：将非组员的进程独立成一个会话，并且该进程变成此会话的组长

2.不能是原先就是组长的进程

/dev/null：黑洞文件，信息重定向到该文件默认数据全部清空丢弃。

2.代码

#define DEV "/dev/null"void daemonself(const char *currPath = nullptr)
{// 1.让调用进程忽略异常信号signal(SIGPIPE, SIG_IGN);// 2.如何让自己不是组长，setsidif (fork() > 0)exit(0);// 守护进程 -- 精灵进程，孤儿进程的一种pid_t n = setsid();assert(n != -1);// 3.守护进程脱离终端，关闭或者重定向以前进程默认打开文件 012int fd = open(DEV, O_RDWR);if (fd >= 0){dup2(fd, 0);dup2(fd, 1);dup2(fd, 2);close(fd);}else{close(0);close(1);close(2);}// 4.可选：进程执行路径发生变化if (currPath)chdir(currPath);
}

1.让调用进程忽略异常信号：不出现进程错误的问题使得守护过程终止

2.让自己不是组长(setsid)：守护化的条件就是进程不能是会话的组长，要想不是，上面的处理方式是fork一个子进程，当前进程直接释放，使得fork的子进程变成孤儿进程，孤儿进程托付给操作系统，此时的组长是bash，那么就可以进行setsid了

3.守护进程脱离终端，关闭或者重定向以前进程默认打开文件 012：不直接关闭，将/dev/null这个黑洞文件重定向到012中。

4.可选：进程执行路径发生变化。将当前进程执行的路径换掉。

5.此时服务端的main函数逻辑为：

int main(int argc, char *argv[])
{if (argc != 2){Usage(argv[0]);exit(USAGE_ERR);}uint16_t port = atoi(argv[1]);std::unique_ptr<tcpServer> tsvr(new tcpServer(port));tsvr->initServer();// 守护进程化daemonself();tsvr->start();return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/24356.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

List与Set的区别

List与Set的区别

List与Set的区别 大家好&#xff0c;在我们平时的代码编写过程中&#xff0c;经常会碰到需要使用到集合类型: List与Set。很多时候&#xff0c;我们可能会将它们视为同一种类型进行使用&#xff0c;但是在实际的编程逻辑中&#xff0c;它们之间是存在很大差别的。接下来我们就…
阅读更多...
召唤神龙打造自己的ChatGPT

召唤神龙打造自己的ChatGPT

在之前的两篇文章中&#xff0c;我介绍了GPT 1和2的模型&#xff0c;并分别用Tensorflow和Pytorch来实现了模型的训练。具体可以见以下文章链接&#xff1a; 1. 基于Tensorflow来重现GPT v1模型_gzroy的博客-CSDN博客 2. 花费7元训练自己的GPT 2模型_gzroy的博客-CSDN博客 有…
阅读更多...
机器人状态估计：robot_localization 功能包使用方法

机器人状态估计：robot_localization 功能包使用方法

机器人状态估计&#xff1a;robot_localization 功能包基本使用 前言功能包简介基本使用数据输入与数据输出坐标系设置性能参数调试 前言 移动机器人的状态估计需要用到很多传感器&#xff0c;因为对单一的传感器来讲&#xff0c;都存在各自的优缺点&#xff0c;所以需要一种多…
阅读更多...
简单工厂模式(Simple Factory)

简单工厂模式(Simple Factory)

简单工厂模式&#xff0c;又称为静态工厂方法(Static Factory Method)模式。在简单工厂模式中&#xff0c;可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例&#xff0c;被创建的实例通常都具有共同的父类。简单工厂模式不属于GoF的23个…
阅读更多...
AutoSAR系列讲解（实践篇）12.1-Diagnostics简介

AutoSAR系列讲解（实践篇）12.1-Diagnostics简介

目录 前言 一、UDS协议 1、Service Identifier（SID） 2、协议规范 3、举个例子 二、Aut
阅读更多...
嵌入式开发学习（STC51-7-矩阵按键）

嵌入式开发学习（STC51-7-矩阵按键）

内容 按下S1-S16键&#xff0c;对应数码管最左边显示0-F 矩阵按键简介 独立按键与单片机连接时&#xff0c;每一个按键都需要单片机的一个I/O 口&#xff0c;若某单片机系统需较多按键&#xff0c;如果用独立按键便会占用过多的I/O口资源&#xff1b;而单片机 系统中I/O口资…
阅读更多...
【elasticsearch】关于elasticsearch的max_result_window限制问题的解决方式思考

【elasticsearch】关于elasticsearch的max_result_window限制问题的解决方式思考

事情起因&#xff1a;我们使用es作为日志搜索引擎&#xff0c;客户收集到的业务日志非常之大&#xff0c;每次查询后&#xff0c;返回页数较多&#xff0c;由于我们web界面限制每页返回150条&#xff0c;当客户翻到66页之后就会报错。 文章目录 前言 二、实验 1.默认生成20条数…
阅读更多...
2.13 Android ebpf非网络相关帮助函数API汇总（十二 本章完）

2.13 Android ebpf非网络相关帮助函数API汇总（十二 本章完）

1.long bpf_user_ringbuf_drain(struct bpf_map *map, void *callback_fn, void *ctx, u64 flags) 描述：从指定的用户环形缓冲区中排出样本，并为每个此类样本调用提供的回调： long (*callback_fn)(struct bpf_dynptr *dynptr, void *ctx); 如果callback_fn返回0，帮助函数…
阅读更多...
docker安装code-service在线开发vscode工具及node版本过低问题

docker安装code-service在线开发vscode工具及node版本过低问题

docker安装code-service 拉去镜像 docker pull codercom/code-server创建项目存放映射路径 mkdir /data/code-service/project运行 这里不唯一&#xff0c;但注意密码 docker run -itd --name code-service -u root -p 1024:8080 -v /data/code-service/project:/home/cod…
阅读更多...
Maven介绍-下载-安装-使用-基础知识

Maven介绍-下载-安装-使用-基础知识

Maven介绍-下载-安装-使用-基础知识 Maven的进阶高级用法可查看这篇文章&#xff1a; Maven分模块-继承-聚合-私服的高级用法 文章目录 Maven介绍-下载-安装-使用-基础知识01. Maven1.1 初识Maven1.1.1 什么是Maven1.1.2 Maven的作用 02. Maven概述2.1 Maven介绍2.2 Maven模型…
阅读更多...
hive编译报错整理

hive编译报错整理

背景 最近在修hive-1.2.0的一个bug&#xff0c;需要修改后重新打包部署到集群&#xff0c;打包的时候报下面的错误&#xff0c;原因很简单&#xff0c;从远程仓库里面已经拉不到这个包了。 org.pentaho:pentaho-aggdesigner-algorithm:jar:5.1.5-jhyde was not found in http…
阅读更多...
Unity进阶--通过PhotonServer实现联网登录注册功能(服务器端)--PhotonServer(二)

Unity进阶--通过PhotonServer实现联网登录注册功能(服务器端)--PhotonServer(二)

文章目录 Unity进阶--通过PhotonServer实现联网登录注册功能(服务器端)--PhotonServer(二)服务器端大体结构图BLL层&#xff08;控制层&#xff09;DAL层&#xff08;数据控制层&#xff09;模型层DLC 服务器配置类 发送消息类 以及消息类 Unity进阶–通过PhotonServer实现联网…
阅读更多...
factoryBean.setTypeAliasesPackage()详解

factoryBean.setTypeAliasesPackage()详解

示例代码 Bean public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {SqlSessionFactoryBean factoryBean new SqlSessionFactoryBean();factoryBean.setDataSource(dataSource);factoryBean.setTypeAliasesPackage("com.itheima.domain");retu…
阅读更多...
HCIP——STP

HCIP——STP

STP 一、STP概述二、二层环路带来的问题1、广播风暴问题2、MAC地址漂移问题3、多帧复制 三、802.1D生成树STP的BPDU1、配置BPDU2、RPC3、COST4、配置BPDU的工作过程5、TCN BPDU6、TCN BPDU的工作原理 四、STP的角色五、STP角色选举六、STP的接口状态七、接口状态的迁移八、STP的…
阅读更多...
minio-分布式文件存储系统

minio-分布式文件存储系统

minio-分布式文件存储系统 minio的简介 MinIO基于Apache License v2.0开源协议的对象存储服务&#xff0c;可以做为云存储的解决方案用来保存海量的图片&#xff0c;视频&#xff0c;文档。由于采用Golang实现&#xff0c;服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置…
阅读更多...
没有jodatime，rust里怎么将字符串转为日期呢？

没有jodatime，rust里怎么将字符串转为日期呢？

关注我&#xff0c;学习Rust不迷路&#xff01;&#xff01; 在 Rust 中&#xff0c;有多种方法可以在时间和字符串之间进行转换。以下是五种常见的方式&#xff1a; 1. 使用 chrono 库进行转换&#xff1a; use chrono::{NaiveDateTime, DateTime, Utc, TimeZone};fn main(…
阅读更多...
Mysql函数

Mysql函数

MySQL -函数 常用字符串函数SELECT... 函数 功能 CONCAT&#xff08;S1&#xff0c;S2....Sn&#xff09; 字符串拼接 LOWER&#xff08;str&#xff09; 将字符串str全部改成小写 UPPER(str) 将字符串str全部改成大写 LPAD(str,n,pad) 左填充&#xff0c;用字符串pa…
阅读更多...
实验5-1 使用函数计算两个复数之积 （10 分）

实验5-1 使用函数计算两个复数之积 （10 分）

本题要求现一个函数计算两个复数之积。 函数接口定义&#xff1a; double result_real, result_imag; void complex_prod( double x1, double y1, double x2, double y2 ); 其中用户传入的参数为两个复数x1y1i和x2y2i&#xff1b;函数complex_prod应将计算结果的实部存放在全局…
阅读更多...
线程间的同步、如何解决线程冲突与死锁

线程间的同步、如何解决线程冲突与死锁

一、线程同步概念&#xff1a; 线程同步是指在多线程编程中&#xff0c;为了保证多个线程之间的数据访问和操作的有序性以及正确性&#xff0c;需要采取一些机制来协调它们的执行。在多线程环境下&#xff0c;由于线程之间是并发执行的&#xff0c;可能会出现竞争条件&#xf…
阅读更多...
【WebRTC---源码篇】（三:一）音频轨

【WebRTC---源码篇】（三:一）音频轨

音频轨的创建时序在Conductor::AddTracks()中 rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(peer_connection_factory_->CreateAudioTrack(kAudioLabel, peer_connection_factory_->CreateAudioSource(cricket::AudioOptions()))); 通过代码我们…
阅读更多...
最新文章

Copyright @ 2022~2023