（三）基于BOOST ASIO实现的UDP服务端和客户端

最新推荐文章于 2025-04-21 22:31:45 发布
最新推荐文章于 2025-04-21 22:31:45 发布
阅读量3.6k 收藏 24
点赞数 6
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xushuilong/article/details/106474355
版权

（三）基于BOOST ASIO实现的UDP服务端

代码

//asio_socket.h
#pragma once
#include <queue>
#include <mutex>
#include <string>
#include <vector>
#include <atomic>
#include <map>
#include <unordered_map>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <assert.h>
#include <condition_variable>
#include <iostream>
#include "glog/init_glog.h"

typedef boost::asio::io_service								io_service_type;
typedef boost::shared_ptr<io_service_type>					io_service_ptr_type;
typedef boost::asio::ip::tcp::resolver						tcp_resolver_type;
typedef boost::asio::ip::udp::resolver						udp_resolver_type;
typedef boost::asio::ip::tcp::socket						tcp_socket_type;
typedef boost::asio::ip::udp::socket						udp_socket_type;
typedef boost::shared_ptr<tcp_socket_type>					tcp_socket_ptr_type;
typedef boost::shared_ptr<udp_socket_type>					udp_socket_ptr_type;
typedef boost::asio::ip::tcp::endpoint						tcp_endpoint_type;
typedef boost::asio::ip::udp::endpoint						udp_endpoint_type;
typedef boost::asio::ip::address							address_type;
typedef boost::asio::ip::address_v4							address_v4_type;
typedef boost::asio::ip::address_v6							address_v6_type;
typedef boost::asio::io_service::work						work_type;
typedef boost::shared_ptr<work_type>						work_ptr_type;
typedef boost::asio::ip::tcp::acceptor						tcp_acceptor_type;
typedef boost::shared_ptr<tcp_acceptor_type>				tcp_acceptor_ptr_type;
typedef boost::asio::deadline_timer							dtimer_type;
typedef boost::system::error_code							error_code_type;
typedef std::vector<char>									buffer_type;

#define TCP_V4												boost::asio::ip::tcp::v4()
#define TCP_V6												boost::asio::ip::tcp::v6()
#define UDP_V4												boost::asio::ip::udp::v4()
#define UDP_V6												boost::asio::ip::udp::v6()
#define TCP_V4_PROTOCOL										boost::asio::ip::tcp::v4().protocol()
#define TCP_V6_PROTOCOL										boost::asio::ip::tcp::v6().protocol()
#define UDP_V4_PROTOCOL										boost::asio::ip::udp::v4().protocol()
#define UDP_V6_PROTOCOL										boost::asio::ip::udp::v6().protocol()

#define BOOST_SLEEP_S(x)									(boost::this_thread::sleep(boost::posix_time::seconds(x)))
#define BOOST_SLEEP_MS(x)									(boost::this_thread::sleep(boost::posix_time::milliseconds(x)))

const size_t tcp_max_readbuf_size = 2000;
const size_t tcp_max_writebuf_size = 2000;
const size_t udp_max_sendbuf_size = 2000;
const size_t udp_max_recvbuf_size = 2000;
const int tcp_max_readbuf_raw_size = 65536;
const int tcp_max_msg_length = 65536;
const int udp_max_msg_length = 65536;
const int tcp_max_connected_server_num = 2;// 64;//服务端最大连接数
const int tcp_server_read_timeout = 15;//服务端连接读取超时时间，若长时间没有心跳将断开连接
const int INFIT_TIME = 0x7FFFFFFF;

//asio_udp_partner.hpp
#include "asio_socket.h"
using std::string;
using std::vector;

class UdpPartner
{
	enum WORK_MODE
	{
		WORK_MODE_SINGLECAST_CLIENT = 0,
		WORK_MODE_SINGLECAST_SERVER = 1,
		WORK_MODE_MULTICAST_RECEIVER = 2,
		WORK_MODE_MULTICAST_SENDER = 3,
	};
	typedef std::pair<string, udp_endpoint_type> UMSG;
private:
	udp_endpoint_type m_remote_ep;//构造时初始化
	udp_endpoint_type m_local_ep;//构造时初始化

	io_service_type m_ios;
	udp_socket_type m_sock;

	std::mutex mut_send_buf;
	std::condition_variable cv_send_buf;
	std::queue<UMSG> m_send_to_buf;

	std::mutex mut_recv_buf;
	std::condition_variable cv_recv_buf;
	std::queue<UMSG> m_recv_from_buf;

	std::atomic<bool> m_stop;
	boost::thread th_send;
	boost::thread th_recv;
	WORK_MODE m_work_mode;
public:
	//多播 udp
	UdpPartner(const string & multicast_ip, int multicast_port,bool multicast_sender=true)
		: m_remote_ep(address_v4_type::from_string(multicast_ip), multicast_port)
		, m_local_ep(address_v4_type::from_string("0.0.0.0"), multicast_port)
		, m_sock(m_ios, boost::asio::ip::udp::v4())
		, m_stop(false)
	{
		if (multicast_sender)
		{
			//多播 udp sender(不绑定本地端口，由系统自动分配)
			m_work_mode = WORK_MODE_MULTICAST_SENDER;
			th_send = boost::thread(boost::bind(&UdpPartner::thread_send_to_loop, this));
		}
		else
		{
			//多播 udp receiver(需要绑定多播端口，用于接收数据)
			m_work_mode = WORK_MODE_MULTICAST_RECEIVER;
			//多播选项设置-BEGIN//
			m_sock.set_option(boost::asio::ip::udp::socket::reuse_address(true));
			m_sock.bind(m_local_ep);
			m_sock.set_option(boost::asio::ip::multicast::join_group(m_remote_ep.address()));
			m_sock.set_option(boost::asio::ip::multicast::enable_loopback(true));
			//多播选项设置-END//
			th_recv = boost::thread(boost::bind(&UdpPartner::thread_recv_from_loop, this));
		}
	}

	//单播client: udp sender
	//@param-remote_ip:对端UDP的IP
	//@param-remote_port:对端UDP绑定的PORT
	//@param-local_port:本端UDP绑定的PORT,若为0，则由系统随机分配。
	//@param-connect_udp:是否保持连接对端UDP
	UdpPartner(const string & remote_ip, int remote_port, int local_port=0, bool connect_udp=true)
		: m_remote_ep(address_v4_type::from_string(remote_ip), remote_port)
		, m_local_ep(boost::asio::ip::udp::v4(), local_port)
		, m_sock(m_ios, boost::asio::ip::udp::v4())
		, m_stop(false)
		, m_work_mode(WORK_MODE_SINGLECAST_CLIENT)
	{
		if (local_port>0)
		{
			m_sock.bind(m_local_ep);
		}
		if (connect_udp)
		{
			error_code_type err;
			m_sock.connect(m_remote_ep, err);
			if (err)
			{
				LOG_INFO_GLOG << "udp connect failed:" << err.message() ;
			}
			else
			{
				LOG_INFO_GLOG << "udp connect success" ;
			}
			th_send = boost::thread(boost::bind(&UdpPartner::thread_send_loop, this));
			th_recv = boost::thread(boost::bind(&UdpPartner::thread_recv_loop, this));
		}
		else
		{
			th_recv = boost::thread(boost::bind(&UdpPartner::thread_recv_from_loop, this));
			th_send = boost::thread(boost::bind(&UdpPartner::thread_send_to_loop, this));
		}
	}

	//单播server: udp receiverd
	//@param-local_port:本端UDP绑定的PORT
	UdpPartner(int local_port)
		: m_remote_ep(udp_endpoint_type())
		, m_local_ep(boost::asio::ip::udp::v4(), local_port)
		, m_sock(m_ios, m_local_ep)
		, m_stop(false)
		, m_work_mode(WORK_MODE_SINGLECAST_SERVER)
	{
		th_recv = boost::thread(boost::bind(&UdpPartner::thread_recv_from_loop, this));
		th_send = boost::thread(boost::bind(&UdpPartner::thread_send_to_loop, this));
	}

	~UdpPartner()
	{
		stop();
	}

	void stop()
	{
		m_stop = true;
		std::queue<UMSG> empty_queue;
		{
			std::unique_lock<std::mutex> lk(mut_recv_buf);
			std::swap(m_recv_from_buf, empty_queue);
			cv_recv_buf.notify_all();
		}
		{
			std::unique_lock<std::mutex> lk(mut_send_buf);
			std::swap(m_send_to_buf, empty_queue);
			cv_send_buf.notify_all();
		}
		if (m_work_mode == WORK_MODE_MULTICAST_RECEIVER)
		{
			m_sock.set_option(boost::asio::ip::multicast::leave_group(m_remote_ep.address()));
		}
		if (th_send.joinable())
		{
			th_send.interrupt();
			th_send.join();
		}
		if (th_recv.joinable())
		{
			th_recv.interrupt();
			th_recv.join();
		}
	}

	void push_send_buf(const string & msg, const udp_endpoint_type & ep = udp_endpoint_type())
	{
		if (m_stop || m_work_mode == WORK_MODE_MULTICAST_RECEIVER)
		{
			return;
		}
		std::unique_lock<std::mutex> lk(mut_send_buf);
		if (m_send_to_buf.size() >= udp_max_sendbuf_size)
		{
			LOG_INFO_GLOG << "send buf overflow";
			m_send_to_buf.pop();
		}
		m_send_to_buf.emplace(msg, ep);
		cv_send_buf.notify_one();
	}

	bool pop_recv_buf(string & msg,udp_endpoint_type & ep)
	{
		if (m_stop || m_work_mode == WORK_MODE_MULTICAST_SENDER)
		{
			return false;
		}
		std::unique_lock<std::mutex> lk(mut_recv_buf);
		cv_recv_buf.wait(lk, [this](){return (!m_recv_from_buf.empty() || m_stop); });
		if (m_stop)
		{
			return false;
		}
		msg = m_recv_from_buf.front().first;
		ep = m_recv_from_buf.front().second;
		m_recv_from_buf.pop();
		return true;
	}

private:
	//连接－单播UDP
	void thread_send_loop()
	{
		LOG_INFO_GLOG << "start thread_send_loop of [connected] udp";
		string msg;
		error_code_type err;
		while (!m_stop)
		{
			boost::this_thread::interruption_point();
			{
				std::unique_lock<std::mutex> lk(mut_send_buf);
				cv_send_buf.wait(lk, [this](){return (!m_send_to_buf.empty() || m_stop); });
				if (m_stop)
				{
					return;
				}
				msg = m_send_to_buf.front().first;
				m_send_to_buf.pop();
			}
			size_t size = m_sock.send(boost::asio::buffer(msg), 0, err);
			if (err)
			{
				LOG_WARN_GLOG << err.message();
				return;
			}
			LOG_INFO_GLOG << "[send to] " << m_remote_ep.address().to_string() 
				<< ":" << m_remote_ep.port() << " >>" << msg;
		}
	}

	void thread_recv_loop()
	{
		LOG_INFO_GLOG << "start thread_recv_loop of [connected] udp";
		error_code_type err;
		char buf[udp_max_msg_length];
		while (!m_stop)
		{
			boost::this_thread::interruption_point();
			memset(buf, 0, udp_max_msg_length);
			size_t size = m_sock.receive(boost::asio::buffer(buf, udp_max_msg_length), 0, err);
			if (err)
			{
				LOG_WARN_GLOG << err.message();
				continue;
			}
			{
				std::unique_lock<std::mutex> lk(mut_recv_buf);
				if (m_recv_from_buf.size() >= udp_max_recvbuf_size)
				{
					LOG_WARN_GLOG << "recv buf overflow";
					m_recv_from_buf.pop();
				}
				string msg(buf);
				m_recv_from_buf.emplace(msg, m_remote_ep);
				LOG_INFO_GLOG << "[recv from] " << m_remote_ep.address().to_string() << ":" << m_remote_ep.port() << " >>" << msg;
			}
			cv_recv_buf.notify_one();
		}
	}

	//未连接-单播UDP//多播UDP
	void thread_send_to_loop()
	{
		LOG_INFO_GLOG << "start thread_send_to_loop of udp";
		string msg;
		error_code_type err;
		udp_endpoint_type the_remote_ep;
		while (!m_stop)
		{
			boost::this_thread::interruption_point();
			{
				std::unique_lock<std::mutex> lk(mut_send_buf);
				cv_send_buf.wait(lk, [this](){return (!m_send_to_buf.empty() || m_stop); });
				if (m_stop)
				{
					return;
				}
				msg = m_send_to_buf.front().first;
				if (m_work_mode == WORK_MODE_SINGLECAST_CLIENT 
					|| m_work_mode == WORK_MODE_SINGLECAST_SERVER)
				{
					//单播
					the_remote_ep = m_send_to_buf.front().second;
				}
				else
				{
					//多播
					the_remote_ep = m_remote_ep;
				}
				m_send_to_buf.pop();
			}
			size_t size = m_sock.send_to(boost::asio::buffer(msg), the_remote_ep, 0, err);
			if (err)
			{
				LOG_WARN_GLOG << err.message();
				return;
			}
			LOG_INFO_GLOG << "[send to] " << the_remote_ep.address().to_string() 
				<< ":" << the_remote_ep.port() << " >>" << msg;
		}
	}

	void thread_recv_from_loop()
	{
		LOG_INFO_GLOG << "start thread_recv_from_loop of udp";
		error_code_type err;
		udp_endpoint_type the_remote_ep;
		char buf[udp_max_msg_length];
		while (!m_stop)
		{
			boost::this_thread::interruption_point();
			memset(buf, 0, udp_max_msg_length);
			size_t size = m_sock.receive_from(boost::asio::buffer(buf, udp_max_msg_length), the_remote_ep, 0, err);
			if (err)
			{
				LOG_WARN_GLOG << err.message();
				continue;
			}
			{
				std::unique_lock<std::mutex> lk(mut_recv_buf);
				if (m_recv_from_buf.size() >= udp_max_recvbuf_size)
				{
					LOG_WARN_GLOG << "recv buf overflow";
					m_recv_from_buf.pop();
				}
				string msg(buf);
				m_recv_from_buf.emplace(msg,the_remote_ep);
				LOG_INFO_GLOG << "[recv from] " << the_remote_ep.address().to_string() 
					<< ":" << the_remote_ep.port() << " >>" << msg;
			}
			cv_recv_buf.notify_one();
		}
	}
};

typedef boost::shared_ptr<UdpPartner>				pUdpPartnerType;

//demo.cpp
#include "asio_udp_partner.hpp"
using namespace std;

int main()
{
	char c;
	while (c = getchar())
	{
		if (c == '1')
		{
			cout << "start UdpPartner of client" << endl;
			UdpPartner c("127.0.0.1", 10087, 0, true);
			while (1)
			{
				string tmp = "client msg:" + to_string(time(nullptr));
				udp_endpoint_type ep(address_v4_type::from_string("10.33.65.23"), 10087);
				BOOST_SLEEP_S(6);
				c.push_send_buf(tmp, ep);
			}
		}
		else if (c == '2')
		{
			cout << "start UdpPartner of server" << endl;
			UdpPartner s(10087);
			while (1)
			{
				string tmp;
				udp_endpoint_type ep;
				if (s.pop_recv_buf(tmp, ep))
				{
					string tmp1 = "server msg----------:" + to_string(time(nullptr));
					s.push_send_buf(tmp1, ep);
				}
			}
		}
		else if (c == '3')
		{
			cout << "start UdpPartner of multicast sender" << endl;
			UdpPartner pub("239.0.0.1", 10086, true);
			while (1)
			{
				string tmp = "multicast send msg:" + to_string(time(nullptr));
				udp_endpoint_type ep;
				BOOST_SLEEP_S(3);
				pub.push_send_buf(tmp, ep);
			}
		}
		else if (c == '4')
		{
			cout << "start UdpPartner of multicast receiver" << endl;
			UdpPartner sub("239.0.0.1", 10086, false);
			while (1)
			{
				string tmp;
				udp_endpoint_type ep;
				sub.pop_recv_buf(tmp, ep);
				BOOST_SLEEP_S(1);
			}
		}
		else
		{
			continue;
		}
	}
	return 0;
}

使用说明

  • 1.本文基于BOOST ASIO实现了UDP的单播，组播（广播与组播仅对端地址不同）；

  • 2.UDP单播实现了客户端和服务端，可通过不同的构造函数构造不同的UDP参与者。

    • UdpPartner(const string & multicast_ip, int multicast_port,bool multicast_sender=true);

    构造UDP组播对象，入参依次为：组播IP、组播port、本次构造的是发送端还是接收端。

    并启动发送或者接收线程。

    • UdpPartner(const string & remote_ip, int remote_port, int local_port=0, bool connect_udp=true);

    构造UDP单播客户端，入参依次为：远程服务端IP、远程服务端port、客户端绑定的本地端口、是否连接。

    并启动发送和接收线程。

    注意：UDP是可以调用connect函数的，但这里的UDP连接与TCP三次握手的连接截然不同。

    UDP连接操作会使内核：1.检查是否存在马上可知的错误。2.记录对端的IP地址和port号，然后马上返回调用进程。一个UDP连接可以多次调用connect函数，以最后一次调用传入的信息为准。

    • UdpPartner(int local_port);

    构造UDP单播服务端，入参为：服务端绑定的本地端口。

    并启动发送和接收线程。

    1. 本文实现中使用生产者－消费者模型。
      对发送端而言，向m_send_to_buf中加入待发送的数据，视为生产。发送线程将从中取出数据进行发送，视为消费。
      对接收线程而言，向m_recv_from_buf中加入已接收的数据，视为生产。接收端从中取出数据进行handle处理，视为消费。
AI编程巅峰对决：我用三个实战案例测试Claude 3.7和Gemini 2.5pro的编程能力！
04-07 776
Gemini 2.5pro发布已经一周了，很多朋友体验来看，认为已经超越Claude 3.7的编程水平，而网上关于这二者测评信息很少，大多数都是集中在3.26号左右的流量文章，各种炸裂和逆天，全部是把官方数据又再复述了一下，没有任何体悟，刚出来没法做很深刻的测评。Gemini在这一轮表现更好，它的代码不仅能正常运行，还有更丰富的功能，如时间戳显示和更完善的筛选系统。然而，Claude的实现在沙盒环境中无法正常使用localStorage，这是一个明显的缺点，表明它对环境限制的感知不如Gemini。
地表最强，Gemini 2.5Pro发布！多模型对比实测到底如何？请看文章
fu1766731950的博客
03-26 2474
DeepSeek-V3-0324 在数学和编程任务上表现出色，是这些领域的佼佼者，但在通用问答能力（GPOA Diamond）上仍有提升空间。相比其他模型，它在数学领域的优势尤为突出，适合需要强大数学推理和代码生成能力的场景。如果您有进一步的问题或需要更深入的分析，请随时告诉我！
刚刚，谷歌最强Gemini 2.5 Pro免费了！数学碾压人类研究生，拿下全球TOP 1
AIBigModel的博客
04-02 1422
甚至，有人用Gemini 2.5 Pro测试了一个项目，使用A*算法为高速列车寻找最优解，这个过程中涉及了优化坡度、转弯半径、多目标优化等难题。在上周三刚刚发布时，Gemini 2.5 Pro，还仅仅面向Gemini Advanced订阅者开放，订阅价格为每月19.99美元。虽然又被GPT-4o吉卜力生图的光芒掩盖了，但毫无疑问，上周的另一技术核弹Gemini 2.5 Pro，也是无可争议的强！当然，如果从原理上看，LLM的确没有在做数学，因为它们的本质仍然是概率性的，是做从训练数据中预测最可能的答案。
OpenAI 深度研究与 Gemini 深度研究：哪个更好？.pdf
02-18
deepseek最新资讯，配置方法，使用技巧，持续更新中
51c大模型~合集110
whaosoft~aiotの开发板商城
02-06 1707
为了解决这一问题，在稠密化过程中，我们对容易引起退化和梯度集中的具有极端延展率的高斯面片进行了筛选，并对其增殖过程进行了限制，从而在不牺牲性能的情况下有效稳定了训练过程，保障了优化过程的顺利进行。大规模场景的重建往往还意味着显著的训练开销，要重建 1.97 平方千米的区域会产生接近两千万的高斯点，这意味着 4.6G 的存储以及 31.5G 的显存开销，以及超过三小时的训练时长。站在 AI 研究者的角度，得到了《苦涩的教训》，意味着在总结教训的过程中明确了什么是「更好」的。第二类则瞄准了相对复杂的问题。
谷歌Gemini 2.5 Flash震撼发布：不只快，更能控！性价比拉满的AI新选择
m0_66917422的博客
04-21 1053
谷歌推出的Gemini 2.5 Flash，可以看作是其在AI模型市场竞争中打出的一张差异化好牌。它没有一味追求最高的性能指标，而是巧妙地在速度、成本、性能和可控性之间找到了一个极具吸引力的平衡点。“可控思考预算”的引入，是其最大的亮点，它赋予了开发者前所未有的灵活性，使得AI模型的应用不再是简单的“选用”或“不用”，而是可以根据场景需求进行“调优”。虽然Gemini 2.5 Flash或许不是当前市场上绝对“最强”的模型，但凭借其出色的性价比和全面的能力，它极有可能成为最具价值和最受欢迎的模型之一。
谷歌发布最新大模型 Gemini，包含多模态、三大版本，还有哪些特点？能力是否超越 GPT-4了？
aresng的博客
12-18 2223
谷歌最新发布的Gemini 2.0大规模语言模型，代表了人工智能技术在多个核心领域的重大突破。作为谷歌AI生态系统中的旗舰产品，Gemini 2.0在架构设计、核心技术、多模态处理、性能优化等方面实现了显著提升。我在本文将深入介绍Gemini 2.0的核心技术，重点详解其关键创新，并辅以图示说明，以便读者全面理解其技术优势和局限性。
Gemini 系列模型详细对比 及 Google AI Studio 免费使用说明
m0_73640344的博客
04-21 1598
(当前 API 免费，可能是实验性或促销性质。通过 UI 使用也免费)(当前 API 免费，可能是实验性或促销性质。通过 UI 使用也免费)(适用于所有上下文长度，API 定价，通过 UI 使用免费)(适用于所有上下文长度，API 定价，通过 UI 使用免费)(注意：免费和付费 RPM 相同，反映其实验性质)(注意：免费和付费 RPM 相同，反映其实验性质)(注：API 定价，通过 UI 使用免费)是的，您的问题理解是正确的。
探索Google Gemini：4款模型的全面解析
因为无知，所以奋斗！
08-06 366
Gemini Ultra 是 Gemini 系列中功能最强大、最复杂的模型。领域受到了广泛关注。从用于高级研究的功能强大的 Gemini Ultra 到用于实时任务的快速高效的 Gemini Flash，每个模型都是针对不同的需求而设计的。在介绍不同的 Gemini 模型之前，我们先来了解一下什么是上下文长度，以及为什么较大的上下文长度很重要。相比于 Ultra 或 Pro，它的参数较少，但具有极快的推理能力和优化的算法。Gemini Nano 是 Gemini 系列中最小、最轻的模型，专门为设备上的。
ChatGLM、Baichuan、LLama、Vicuna、Gemini、Qwen2.5对比总结
taoqick的专栏
02-28 1104
这部分转载自 https://www.zhihu.com/question/608732789/answer/3141379386。
[250421] 谷歌发布 Gemini 2.5 Flash 预览版：更快、更智能、更经济高效的 AI 新选择
edwinjhlee的博客
04-21 556
总而言之，Gemini 2.5 Flash 的推出，为广大用户和开发者提供了一个在速度、智能与成本效益之间取得更优平衡的强大 AI 工具。无论是需要快速响应的日常应用，还是需要更深度思考的任务，它都展现出了巨大的潜力。这款新模型是基于备受欢迎的 2.0 Flash 版本构建的，并在推理能力上实现了重大升级，同时依然将速度和成本效益放在首位。与其他一些先进模型相比，它在保持较低成本的同时，展现了具有竞争力的性能水平。用户可以在模型选择器中找到它，并可以配合 Gemini 应用中的新功能，例如。
谷歌最新发布的Gemini 2.5 Pro系列模型
我是赛博AI Lewis
03-27 994
Gemini 2.5 Pro代表了当前AI模型在推理、多模态和代码生成领域的最高水平，尤其在处理复杂任务时展现出的“类人思考”能力使其成为学术界、企业及开发者的强力工具。随着OpenAI等竞争对手的跟进，未来AI模型竞赛将更加激烈。
大模型成本效益对比：DeepSeek 2.5 VS Claude 3.5 Sonnet VS GPT-4o
OneFlow深度学习框架
09-27 8681
与Claude和GPT模型相比，DeepSeek模型过去一度被开发者社区忽视。不过，过去几个月以来，DeepSeek的发展势头非常迅猛。随着DeepSeek 2.5发布（该版本整合了DeepSeek-V2-Chat和DeepSeek-Coder-V2-Instruct的功能），该模型热度达到顶峰。DeepSe...
DeepSeek-V3、Qwen2.5、Llama3.1、Claude-3.5 与 GPT-4o 的全方位比较
llm_way的博客
02-03 5332
研究发现，DeepSeek-V3以其高效的MoE架构和全面的性能表现脱颖而出，成为最佳通才模型。而Claude-3.5在英语问答领域表现出色，成为最佳英语QA模型。Qwen2.5则在编程和代码编辑等任务中展现出强大的性能，成为最佳编码模型。GPT-4o则以其强大的多语言能力在多语言应用场景中具有广泛的应用前景。
Llama 4 模型深度解析：架构创新 × 多版本对比 × 应用实战
在信息的熵增中，记录结构、重建秩序。 技术思想者的笔记，系统构建者的注释。
04-06 2032
Meta 于 2025 年 4 月发布了全新一代大语言模型 Llama 4 系列，首发 Scout 与 Maverick 两个版本，并曝光 Behemoth 超大模型架构。本文将围绕模型结构、能力评估、实际应用、技术亮点以及未来展望进行全面解读。
NLP高频面试题（四十八）——大语言模型中的思维链（CoT）技术详解
最新发布
WeLearnNLP
04-21 734
思维链（Chain of Thought）技术的出现，为大型语言模型破解复杂推理任务开辟了一条新路。从最初在GPT-3上实验出惊人的效果，到如今融入GPT-4、Claude、Gemini等顶级模型的“思维”机制，CoT已经成为大模型能力版图中不可或缺的一部分。通过让模型模仿人类的逐步推理，我们显著提升了模型在数学、逻辑、常识等领域的表现，也让模型的决策过程更加透明、可监控。
谷歌大模型“性价比之王”来了！混合推理模型，思考深度可自由控制，竞技场排名仅次于自家Pro
量子位
04-18 690
另外由于Gemini的Flash版本和OpenAI的mini类似，再加上上线时间邻近，Gemini 2.5 Flash也被视为o4-mini的竞争者。实际上，如果按照输入输出3:1的比例计算，在大模型竞技场1400分附近，Gemini 2.5 Flash是最便宜的一款模型。不过从谷歌官方发布的成绩单上看，Gemini 2.5 Flash在一些难度较高的测试集中，表现是要稍逊于o4-mini的。当然，实际应用还是要看具体任务，不过可以确定的是，Gemini 2.5 Flash的性价比已经获得了部分人的认可。
Gemini 2.5 Flash: 谷歌混合推理革命，AI思考能力与性价比的完美平衡
AI智能体研究
04-20 1038
根据Google官方数据，Gemini 2.5 Flash在各项人工智能评测基准(Benchmark)中的表现都可以直接挑战目前主打性价比的大型语言模型，例如OpenAI的o4-mini，Anthropic的Sonnet 3.7，xAI的Grok 3和DeepSeek R1，所以这款模型的定位就是极致性价比，覆盖从最便宜的2.0 Flash到最高性能的2.5 Pro之间的中端需求市场，用户可以根据自己的特定应用场景和需求选择不同的思考预算。更高的预算允许模型进行更深入的推理，从而提高输出质量。
Gemini API 最新进展：Gemini 2.5 Flash & Pro、Live API、Veo 2
谷歌开发者
04-11 993
本次发布亮点包括：最新的 Gemini 2.5 思考模型，实时互动体验的 Live API 的最新进展，以及正式面向开发者开放的高质量视频生成工具 Veo 2。从 Gemini 2.5 更为强大的思考能力，到通过 Live API 实现的实时互动，以及 Veo 2 突破性的视频生成能力，我们热切期待各位开发者能够创造出令人瞩目的创新成果！作为我们热门主力模型的演进版本，Gemini 2.5 Flash 在保持低延迟和高性价比的同时，融入了强大的思考能力。我们将为您提供平台和资源，助力您在分享中提升技能。
leetcodehot100怎么刷
01-15
### 如何高效解决 LeetCode 热门 100 题 #### 制定学习计划 为了高效完成 LeetCode 的热门题目，制定合理的学习计划至关重要。可以按照难度逐步提升的方式来进行练习，先从简单题入手，逐渐过渡到中等和困难级别。 #### 掌握基础数据结构与算法 熟悉常用的数据结构（如栈、队列、哈希表等）以及经典算法（排序、查找），这有助于快速理解并解决问题[^1]。 对于给定的例子 `最长有效括号`，通过使用栈来追踪未匹配的左括号位置，并计算最大长度： ```cpp class Solution { public: int longestValidParentheses(string s) { int ans = 0; std::stack<int> stk; stk.push(-1); for (int i = 0; i < s.size(); ++i){ if (s[i] == '(') stk.push(i); else{ stk.pop(); if (stk.empty()) stk.push(i); else ans = std::max(ans, i - stk.top()); } } return ans; } }; ``` 另一个例子是移除有序数组中的重复项，这里采用双指针技巧提高效率： ```java public int removeDuplicates(int[] nums) { if (nums == null || nums.length == 0) { return 0; } int index = 0; for (int i = 1; i < nums.length; ++i) { if (nums[i] != nums[index]) { index++; nums[index] = nums[i]; } } return index + 1; } ``` 针对两数之和问题，则可以通过构建哈希表实现线性时间复杂度内的求解方案： ```cpp std::vector<int> twoSum(std::vector<int>& nums, int target) { std::unordered_map<int, int> map; for (size_t i = 0; i < nums.size(); ++i) { auto it = map.find(target - nums[i]); if (it != map.end()) { return {static_cast<int>(it->second), static_cast<int>(i)}; } map[nums[i]] = i; } throw "No solution"; } ``` #### 多做总结归纳 每做完一道题之后都要认真思考其背后的原理和技术要点，尝试寻找相似类型的其他题目加以巩固训练。同时也要注意积累一些常用的编程模式或模板以便日后调用。 #### 积极参与社区交流 加入讨论区与其他开发者互动交流心得体验，不仅可以拓宽视野还能及时获取最新的技术资讯和发展趋势。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值