SrsAutoFree模式，避免内存泄漏和错误

本文链接：https://blog.csdn.net/win_lin/article/details/13621145

本文深入探讨了C/C++中内存管理的挑战，特别是内存泄漏、多次释放和越界等问题，并介绍了如何通过智能指针AutoFree来解决内存管理难题。重点分析了内存生命周期管理，特别在while循环中对象释放时机的重要性，以及如何确保对象在特定作用域内只释放一次。此外，还对比了AutoFree模式与常规内存管理方式的区别，并通过实例展示了其在消息处理场景中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C/C++中内存是一个很难处理的事情，正如强项就是弱项，强大的地方也是致命的地方。

内存不释放就会泄漏，多次释放就会段错误，越界更恐怖。

不释放和多次释放都可以用SrsAutoFree规避，越界就需要工具和经验的问题。

释放和多次释放，原因是内存或者对象的生命周期过程，譬如在一个while循环中，有些时候要释放，有些时候continue就好，就容易出问题。

真的需要活N久的对象吗？很少。大部分的作用域在当前函数和子函数，局部变量就可以搞定，是的，有些时候就是没有办法用局部变量，譬如由一个函数收取的包，在当前函数就需要释放。

考虑下面的逻辑：

int SrsClient::publish(SrsSource* source, bool is_fmle)
{
	int ret = ERROR_SUCCESS;
	
	SrsPithyPrint pithy_print(SRS_STAGE_PUBLISH_USER);
	
	while (true) {
		// switch to other st-threads.
		st_usleep(0);
		
		SrsCommonMessage* msg = NULL;
		if ((ret = rtmp->recv_message(&msg)) != ERROR_SUCCESS) {
			srs_error("recv identify client message failed. ret=%d", ret);
			return ret;
		}

		SrsAutoFree(SrsCommonMessage, msg, false);
		
		pithy_print.set_age(msg->header.timestamp);

		// reportable
		if (pithy_print.can_print()) {
			srs_trace("<- clock=%u, time=%"PRId64", obytes=%"PRId64", ibytes=%"PRId64", okbps=%d, ikbps=%d", 
				(int)srs_get_system_time_ms(), pithy_print.get_age(), rtmp->get_send_bytes(), rtmp->get_recv_bytes(), rtmp->get_send_kbps(), rtmp->get_recv_kbps());
		}
		
		// process audio packet
		if (msg->header.is_audio() && ((ret = source->on_audio(msg)) != ERROR_SUCCESS)) {
			srs_error("process audio message failed. ret=%d", ret);
			return ret;
		}
		// process video packet
		if (msg->header.is_video() && ((ret = source->on_video(msg)) != ERROR_SUCCESS)) {
			srs_error("process video message failed. ret=%d", ret);
			return ret;
		}
		
		// process onMetaData
		if (msg->header.is_amf0_data() || msg->header.is_amf3_data()) {
			if ((ret = msg->decode_packet()) != ERROR_SUCCESS) {
				srs_error("decode onMetaData message failed. ret=%d", ret);
				return ret;
			}
		
			SrsPacket* pkt = msg->get_packet();
			if (dynamic_cast<SrsOnMetaDataPacket*>(pkt)) {
				SrsOnMetaDataPacket* metadata = dynamic_cast<SrsOnMetaDataPacket*>(pkt);
				if ((ret = source->on_meta_data(msg, metadata)) != ERROR_SUCCESS) {
					srs_error("process onMetaData message failed. ret=%d", ret);
					return ret;
				}
				srs_trace("process onMetaData message success.");
				continue;
			}
			
			srs_trace("ignore AMF0/AMF3 data message.");
			continue;
		}
		
		// process UnPublish event.
		if (msg->header.is_amf0_command() || msg->header.is_amf3_command()) {
			if ((ret = msg->decode_packet()) != ERROR_SUCCESS) {
				srs_error("decode unpublish message failed. ret=%d", ret);
				return ret;
			}
			
			// flash unpublish.
			if (!is_fmle) {
				srs_trace("flash publish finished.");
				return ret;
			}
		
			SrsPacket* pkt = msg->get_packet();
			if (dynamic_cast<SrsFMLEStartPacket*>(pkt)) {
				SrsFMLEStartPacket* unpublish = dynamic_cast<SrsFMLEStartPacket*>(pkt);
				return rtmp->fmle_unpublish(res->stream_id, unpublish->transaction_id);
			}
			
			srs_trace("ignore AMF0/AMF3 command message.");
			continue;
		}
	}
	
	return ret;
}

从RTMP协议栈拿到包后，使用在这个作用域一定会释放，所以使用AutoFree就可以保证只释放一次，而且一定释放一次。

AutoFree实现很可靠，用C++的构造和析构，以及宏定义就可以搞定。

/*
The MIT License (MIT)

Copyright (c) 2013 winlin

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef SRS_CORE_AUTO_FREE_HPP
#define SRS_CORE_AUTO_FREE_HPP

/*
#include 
   
   
    
    
*/

#include 
    
    
     
     

/**
* auto free the instance in the current scope.
*/
#define SrsAutoFree(className, instance, is_array) \
	__SrsAutoFree
     
     
      
       _auto_free_##instance(&instance, is_array)
    
template
      
      
       
       
class __SrsAutoFree
{
private:
    T** ptr;
    bool is_array;
public:
    /**
    * auto delete the ptr.
    * @is_array a bool value indicates whether the ptr is a array.
    */
    __SrsAutoFree(T** _ptr, bool _is_array){
        ptr = _ptr;
        is_array = _is_array;
    }
    
    virtual ~__SrsAutoFree(){
        if (ptr == NULL || *ptr == NULL) {
            return;
        }
        
        if (is_array) {
            delete[] *ptr;
        } else {
            delete *ptr;
        }
        
        *ptr = NULL;
    }
};


#endif

对比以下代码，没有使用auto free模式：

// ignore when no messages.
int count = (int)msgs.size();
if (msgs.empty()) {
        continue;
}

// all msgs to forward.
int i = 0;
for (i = 0; i < count; i++) {
        SrsSharedPtrMessage* msg = msgs[i];
        msgs[i] = NULL;

        // we erased the sendout messages, the msg must not be NULL.
        srs_assert(msg);
        
        ret = client->send_message(msg);
        if (ret != ERROR_SUCCESS) {
                srs_error("forwarder send message to server failed. ret=%d", ret);

                // convert the index to count when error.
                i++;
                
                break;
        }
}

// clear sendout mesages.
if (i < count) {
        srs_warn("clear forwarded msg, total=%d, forwarded=%d, ret=%d", count, i, ret);
} else {
        srs_info("clear forwarded msg, total=%d, forwarded=%d, ret=%d", count, i, ret);
}
msgs.erase(msgs.begin(), msgs.begin() + i);

if (ret != ERROR_SUCCESS) {
        break;
}

使用auto free模式后：

// ignore when no messages.
if (count <= 0) {
    srs_verbose("no packets to forward.");
    continue;
}
SrsAutoFree(SrsSharedPtrMessage*, msgs, true);

// all msgs to forward.
for (int i = 0; i < count; i++) {
    SrsSharedPtrMessage* msg = msgs[i];
    
    srs_assert(msg);
    msgs[i] = NULL;
    
    if ((ret = client->send_message(msg)) != ERROR_SUCCESS) {
        srs_error("forwarder send message to server failed. ret=%d", ret);
        return ret;
    }
}

如下图：