请教， sync.Pool 怎么正确缓存一个列表？

相关代码如下，我能确保的是，Create 和 Release 是成对出现的；通过下面代码第一次拿到的数据是对的，多次就会出现混乱了。

func (r *ApplicationRepository) GetApplications(filter string, orderBy string, page int, pageSize int) (*model.ApplicationCollection, error) {

	var sqlx strings.Builder
	var args []any

	sqlx.WriteString("SELECT `id`, `application_name`, `created_at`, `updated_at` ")
	sqlx.WriteString("FROM `applications` ")
	sqlx.WriteString("WHERE `status` >= 0 ")

	if filter != "" {
		sqlx.WriteString("AND ")
		if err := utils.SqlFilter(filter, &sqlx, &args, "", r.tryParse); err != nil {
			return nil, err
		}
		sqlx.WriteString(" ")
	}

	if orderBy != "" {
		sqlx.WriteString("ORDER BY ")
		if err := utils.SqlOrderBy(orderBy, &sqlx, "", r.tryParseKey); err != nil {
			return nil, err
		}
		sqlx.WriteString(" ")
	}

	sqlx.WriteString("limit ? offset ?")

	if pageSize > _maxPageSize {
		pageSize = _maxPageSize
	} else if pageSize <= 0 {
		pageSize = _pageSize
	}

	offset := 0

	if page > 1 {
		offset = (page - 1) * pageSize
	}

	args = append(args, pageSize, offset)

	rows, err := query(sqlx.String(), args...)

	if err != nil {
		return nil, err
	}

	defer rows.Close()

	applications := model.CreateApplicationCollection()

	for rows.Next() {

		application := model.CreateApplication()

		err := rows.Scan(&application.ID, &application.ApplicationName, &application.CreatedAt, &application.UpdatedAt)

		if err != nil {
			return nil, err
		}

		*applications = append(*applications, *application)
	}

	return applications, rows.Err()
}

package model

import (
	"time"
)

// Application model
// @Entity tableName="applications"
type Application struct {
	// @PrimaryKey
	ID uint64 `json:"id"`
	ApplicationName string `json:"applicationName"`
	CreatedAt *time.Time `json:"createdAt"`
	UpdatedAt *time.Time `json:"updatedAt"`
}

// ApplicationCollection Application list
type ApplicationCollection []Application

package model

import "sync"

var (
	_applicationPool = sync.Pool{
		New: func() any {
			application := &Application{}
			return application
		}}

	_applicationsPool = sync.Pool{
		New: func() any {
			applications := &ApplicationCollection{}
			return applications
		}}
)

// CreateApplication return *Application
func CreateApplication() *Application {

	application := _applicationPool.Get().(*Application)

	return application
}

func (o *Application) initial() {
	o.ID = 0
	o.ApplicationName = ""
	o.CreatedAt = nil
	o.UpdatedAt = nil
}

func (o *Application) Release() {
	o.initial()
	_applicationPool.Put(o)
}

// CreateApplicationCollection return *ApplicationCollection
func CreateApplicationCollection() *ApplicationCollection {

	applicationCollection := _applicationsPool.Get().(*ApplicationCollection)

	return applicationCollection
}

func (o *ApplicationCollection) initial() {
	*o = (*o)[0:0]
}

func (o *ApplicationCollection) Release() {
	for i := 0; i < o.Len(); i++ {
		(*o)[i].Release()
	}
	o.initial()
	_applicationsPool.Put(o)
}