Erlang的port的释放过程
static void terminate_port(Port *prt)
{
Eterm send_closed_port_id;
Eterm connected_id = NIL /* Initialize to silence compiler */;
erts_driver_t *drv;
ERTS_SMP_CHK_NO_PROC_LOCKS;
ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
ASSERT(!prt->nlinks);
ASSERT(!prt->monitors);
if (prt->status & ERTS_PORT_SFLG_SEND_CLOSED) {
erts_port_status_band_set(prt, ~ERTS_PORT_SFLG_SEND_CLOSED);
send_closed_port_id = prt->id;
connected_id = prt->connected;
}
else {
send_closed_port_id = NIL;
}
#ifdef ERTS_SMP
erts_cancel_smp_ptimer(prt->ptimer);
#else
erts_cancel_timer(&prt->tm);
#endif
drv = prt->drv_ptr;
if ((drv != NULL) && (drv->stop != NULL)) {
int fpe_was_unmasked = erts_block_fpe();
(*drv->stop)((ErlDrvData)prt->drv_data);
/* 若有则调用port的driver的stop函数 */
erts_unblock_fpe(fpe_was_unmasked);
#ifdef ERTS_SMP
if (prt->xports)
erts_smp_xports_unlock(prt);
ASSERT(!prt->xports);
#endif
}
if(drv->handle != NULL) {
erts_smp_mtx_lock(&erts_driver_list_lock);
erts_ddll_decrement_port_count(drv->handle);
/* 若driver使用了动态链接库或共享库，则减少其引用计数 */
erts_smp_mtx_unlock(&erts_driver_list_lock);
}
stopq(prt); /* clear queue memory */
if(prt->linebuf != NULL){
erts_free(ERTS_ALC_T_LINEBUF, (void *) prt->linebuf);
/* 释放用于保存未集齐的数据的线性缓冲区 */
prt->linebuf = NULL;
}
if (prt->bp != NULL) {
free_message_buffer(prt->bp);
/* 释放堆分片 */
prt->bp = NULL;
prt->data = am_undefined;
}
if (prt->psd)
erts_free(ERTS_ALC_T_PRTSD, prt->psd);
/* 释放port特定数据结构占用的内存 */
kill_port(prt);
/*
* We don't want to send the closed message until after the
* port has been removed from the port table (in kill_port()).
*/
if (is_internal_port(send_closed_port_id))
deliver_result(send_closed_port_id, connected_id, am_closed);
ASSERT(prt->dist_entry == NULL);
}
static ERTS_INLINE void kill_port(Port *pp)
{
ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(pp));
erts_port_task_free_port(pp);
ASSERT(pp->status & ERTS_PORT_SFLGS_DEAD);
}
void erts_port_task_free_port(Port *pp)
{
ErtsRunQueue *runq;
int port_is_dequeued = 0;
ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(pp));
ASSERT(!(pp->status & ERTS_PORT_SFLGS_DEAD));
runq = erts_port_runq(pp);
ASSERT(runq);
ERTS_PT_CHK_PRES_PORTQ(runq, pp);
if (pp->sched.exe_taskq) {
/* I (this thread) am currently executing this port, free it
when scheduled out... */
ErtsPortTask *ptp = port_task_alloc();
erts_smp_port_state_lock(pp);
pp->status &= ~ERTS_PORT_SFLG_CLOSING;
pp->status |= ERTS_PORT_SFLG_FREE_SCHEDULED;
erts_may_save_closed_port(pp);
erts_smp_port_state_unlock(pp);
ERTS_SMP_LC_ASSERT(erts_smp_atomic_read(&pp->refc) > 1);
ptp->type = ERTS_PORT_TASK_FREE;
ptp->event = (ErlDrvEvent) -1;
ptp->event_data = NULL;
set_handle(ptp, NULL);
push_task(pp->sched.exe_taskq, ptp);
ERTS_PT_CHK_PRES_PORTQ(runq, pp);
erts_smp_runq_unlock(runq);
}
else {
/* 仅仅分析这个简单的场景以说明问题，另外一个场景类似 */
ErtsPortTaskQueue *ptqp = pp->sched.taskq;
if (ptqp) {
dequeue_port(runq, pp);
ERTS_PORT_NOT_IN_RUNQ(pp);
port_is_dequeued = 1;
}
erts_smp_port_state_lock(pp);
pp->status &= ~ERTS_PORT_SFLG_CLOSING;
pp->status |= ERTS_PORT_SFLG_FREE_SCHEDULED;
/* port的状态被更改为了ERTS_PORT_SFLG_FREE_SCHEDULED，它也是ERTS_PORT_SFLGS_DEAD的一种 */
erts_may_save_closed_port(pp);
/* 能够让erts_dead_ports_ptr保存已经退出的port，则port在退出时一定走到了这里，我们其实仅需要关注在这里之后是否有port资源泄露即可 */
erts_smp_port_state_unlock(pp);
#ifdef ERTS_SMP
erts_smp_atomic_dec(&pp->refc); /* Not alive */
#endif
ERTS_SMP_LC_ASSERT(erts_smp_atomic_read(&pp->refc) > 0); /* Lock */
handle_remaining_tasks(runq, pp); /* May release runq lock */
/*这个函数将释放挂在port上的所有ErtsPortTask，port能够执行的各项任务，也被像消息一样发给port，由port异步执行，这里将释放port的任务队列上的所有ErtsPortTask任务的数据结构*/
ASSERT(!pp->sched.exe_taskq && (!ptqp || !ptqp->first));
pp->sched.taskq = NULL;
ERTS_PT_CHK_PRES_PORTQ(runq, pp);
#ifndef ERTS_SMP
ASSERT(pp->status & ERTS_PORT_SFLG_PORT_DEBUG);
erts_port_status_set(pp, ERTS_PORT_SFLG_FREE);
/* port的状态又被改为了ERTS_PORT_SFLG_FREE，它也是ERTS_PORT_SFLGS_DEAD的一种，但设置为这个状态后，表名port原先的描述符Port数据结构可以被重新分配给一个新建立的port了，因为之前已经触发了erts_may_save_closed_port，因此按照顺序执行流的执行，除非发生异常，否则必然会到此处 */
#endif
erts_smp_runq_unlock(runq);
if (erts_system_profile_flags.runnable_ports && port_is_dequeued) {
profile_runnable_port(pp, am_inactive);
}
if (ptqp)
port_taskq_free(ptqp);
/*释放port的任务队列*/
}
}
由此可见port的释放其实没有那么复杂，虚拟机本身就有port数量限制，每次的port释放都仅仅将port的描述符设置为ERTS_PORT_SFLG_FREE以进行复用，而不会真正释放数据结构。
再来看看用于获取空闲port描述符的get_free_port：
io.c
static int get_free_port(void)
{
Uint num;
Uint tries = erts_max_ports;
Port* port;
erts_smp_spin_lock(&get_free_port_lck);
num = last_port_num + 1;
for (;; ++num) {
port = &erts_port[num & erts_port_tab_index_mask];
erts_smp_port_state_lock(port);
if (port->status & ERTS_PORT_SFLG_FREE) {
last_port_num = num;
erts_smp_spin_unlock(&get_free_port_lck);
break;
}
erts_smp_port_state_unlock(port);
if (--tries == 0) {
erts_smp_spin_unlock(&get_free_port_lck);
return -1;
}
}
port->status = ERTS_PORT_SFLG_INITIALIZING;
#ifdef ERTS_SMP
ERTS_SMP_LC_ASSERT(erts_smp_atomic_read(&port->refc) == 0);
erts_smp_atomic_set(&port->refc, 2); /* Port alive + lock */
#endif
erts_smp_port_state_unlock(port);
return num & port_num_mask;
}
get_free_port用于取得一个空闲port描述符，它将遍历erts_port记录的所有port描述符，然后从中取得一个状态为ERTS_PORT_SFLG_FREE的描述符。
由此可见port的分配与释放都不会引发port描述符的内存分配与释放，仅仅会复用一个而已。
至此，问题原因已经基本清楚了，erlang:ports()和erlang:processes()将返回在某个时刻的端口和进程的快照，这样的结果更加一致，因为时刻的快照比时间间隔的快照更加精准。