A*算法的关闭列表中存在一个循环的问题是由于算法在搜索过程中可能会重复访问相同的节点导致的。这种情况通常发生在存在环路的图形结构中，或者在启发式函数（heuristic function）不准确时。

下面是一个解决该问题的示例代码：

class Node:
    def __init__(self, state, parent=None):
        self.state = state
        self.parent = parent
        self.g = 0  # 距离起始点的实际代价
        self.h = 0  # 启发函数的估计代价
        self.f = 0  # 综合代价评估值

def A_star_search(start, goal):
    open_list = []
    closed_list = []

    # 将起始节点加入open列表
    open_list.append(start)

    while open_list:
        current_node = open_list[0]
        current_index = 0

        # 找出open列表中f值最小的节点
        for index, node in enumerate(open_list):
            if node.f < current_node.f:
                current_node = node
                current_index = index

        # 将当前节点从open列表中移除，并加入closed列表
        open_list.pop(current_index)
        closed_list.append(current_node)

        # 判断是否到达目标节点
        if current_node == goal:
            path = []
            while current_node:
                path.append(current_node.state)
                current_node = current_node.parent
            return path[::-1]  # 返回倒序的路径

        # 扩展当前节点的子节点
        children = []
        for new_state in get_neighbors(current_node.state):
            new_node = Node(new_state, current_node)
            children.append(new_node)

        # 对子节点进行评估和排序，并加入open列表
        for child in children:
            # 检查子节点是否在closed列表中，若存在则跳过
            if child in closed_list:
                continue

            # 计算子节点的g, h, f值
            child.g = current_node.g + distance_between(current_node, child)
            child.h = heuristic(child, goal)
            child.f = child.g + child.h

            # 检查子节点是否在open列表中，并且新的路径是否更优
            for open_node in open_list:
                if child == open_node and child.g > open_node.g:
                    continue

            # 将子节点加入open列表
            open_list.append(child)

在示例代码中，我们使用了一个closed_list来跟踪已经访问过的节点。如果子节点已经存在于closed_list中，则跳过该节点的评估和扩展过程，以避免形成循环。

另外，算法中的启发函数（heuristic）和距离函数（distance_between）也需要根据具体问题进行实现。启发函数用于估计当前节点到目标节点的代价，距离函数用于计算两个节点之间的实际代价。

通过在算法中引入closed_list并进行检查，可以有效解决A*算法中关闭列表中存在循环的问题。