Eclipse内存占用过高致输入延迟，求优化方案（附Deque代码）

• 操作输入时出现明显延迟，通过任务管理器观察到Eclipse内存占用高达9435.6MB，同时存在9个重复的Python进程。
• 尝试关闭并重启Eclipse后，问题仍未解决。

以下是补全后的双端队列代码，包含所有未完成方法的逻辑实现：

from copy import deepcopy

class _Deque_Node:
    def __init__(self, value, _prev, _next):
        """
        -------------------------------------------------------
        初始化双端队列节点
        使用: node = _Deque_Node(value, _prev, _next)
        -------------------------------------------------------
        参数:
            value - 节点存储的值(任意类型)
            _prev - 前驱节点(_Deque_Node类型)
            _next - 后继节点(_Deque_Node类型)
        返回:
            新的_Deque_Node对象(_Deque_Node)
        -------------------------------------------------------
        """
        self._value = deepcopy(value)
        self._prev = _prev
        self._next = _next

class Deque:
    def __init__(self):
        """
        -------------------------------------------------------
        初始化空双端队列
        使用: d = Deque()
        -------------------------------------------------------
        返回:
            新的Deque对象(Deque)
        -------------------------------------------------------
        """
        self._front = None
        self._rear = None
        self._count = 0

    def is_empty(self):
        """
        -------------------------------------------------------
        判断双端队列是否为空
        使用: b = deque.is_empty()
        -------------------------------------------------------
        返回:
            队列为空返回True，否则返回False
        -------------------------------------------------------
        """
        return self._count == 0

    def __len__(self):
        """
        -------------------------------------------------------
        返回双端队列的大小
        使用: n = len(deque)
        -------------------------------------------------------
        返回:
            队列中元素的数量(int)
        -------------------------------------------------------
        """ 
        return self._count

    def __eq__(self, target):
        """
        ---------------------------------------------------------
        判断两个双端队列是否相等
        比较self和target中的所有元素，若所有元素值相等且顺序一致则返回True，否则返回False
        使用: equals = source == target
        ---------------
        参数:
            target - 另一个双端队列(Deque)
        返回:
            equals - 若source和target元素值及顺序均相同则为True，否则为False(bool)
        -------------------------------------------------------
        """
        if self._count != target._count:
            return False
        
        current_self = self._front
        current_target = target._front
        
        while current_self is not None:
            if current_self._value != current_target._value:
                return False
            current_self = current_self._next
            current_target = current_target._next
        
        return True

    def insert_front(self, value):
        """
        -------------------------------------------------------
        将value的副本插入到双端队列的前端
        使用: deque.insert_front(value)
        -------------------------------------------------------
        参数:
            value - 要插入的元素(任意类型)
        返回:
            None
        -------------------------------------------------------
        """
        new_node = _Deque_Node(value, None, self._front)
        
        if self._front is not None:
            self._front._prev = new_node
        else:
            # 队列为空时，插入的节点同时是队尾
            self._rear = new_node
        
        self._front = new_node
        self._count += 1
        return

    def insert_rear(self, value):
        """
        -------------------------------------------------------
        将value的副本插入到双端队列的后端
        使用: deque.insert_rear(value)
        -------------------------------------------------------
        参数:
            value - 要插入的元素(任意类型)
        返回:
            None
        -------------------------------------------------------
        """
        new_node = _Deque_Node(value, self._rear, None)
        
        if self._rear is not None:
            self._rear._next = new_node
        else:
            # 队列为空时，插入的节点同时是队头
            self._front = new_node
        
        self._rear = new_node
        self._count += 1
        return

    def remove_front(self):
        """
        -------------------------------------------------------
        移除并返回双端队列前端的元素
        使用: v = deque.remove_front()
        -------------------------------------------------------
        返回:
            value - 队列前端的元素(任意类型)
        -------------------------------------------------------
        """
        assert not self.is_empty(), "无法从空队列中移除元素"
        
        value = deepcopy(self._front._value)
        self._front = self._front._next
        
        if self._front is not None:
            self._front._prev = None
        else:
            # 移除后队列为空，更新队尾
            self._rear = None
        
        self._count -= 1
        return value

    def remove_rear(self):
        """
        -------------------------------------------------------
        移除并返回双端队列后端的元素
        使用: v = deque.remove_rear()
        -------------------------------------------------------
        返回:
            value - 队列后端的元素(任意类型)
        -------------------------------------------------------
        """
        assert not self.is_empty(), "无法从空队列中移除元素"
        
        value = deepcopy(self._rear._value)
        self._rear = self._rear._prev
        
        if self._rear is not None:
            self._rear._next = None
        else:
            # 移除后队列为空，更新队头
            self._front = None
        
        self._count -= 1
        return value

    def peek_front(self):
        """
        -------------------------------------------------------
        查看双端队列前端的元素(不移除)
        使用: v = deque.peek_front()
        -------------------------------------------------------
        返回:
            value - 队列前端元素的副本(任意类型)
        -------------------------------------------------------
        """
        assert not self.is_empty(), "无法查看空队列的前端元素"
        
        return deepcopy(self._front._value)

    def peek_rear(self):
        """
        -------------------------------------------------------
        查看双端队列后端的元素(不移除)
        使用: v = deque.peek_rear()
        -------------------------------------------------------
        返回:
            value - 队列后端元素的副本(任意类型)
        -------------------------------------------------------
        """
        assert not self.is_empty(), "无法查看空队列的后端元素"
        
        return deepcopy(self._rear._value)

    def _swap(self, l, r):
        """
        -------------------------------------------------------
        交换双端队列中的两个节点位置。l和r互换位置，_front和_rear会根据情况更新
        不移动节点中的数据，仅调整指针
        使用: self._swap(l, r)
        -------------------------------------------------------
        参数:
            l - 指向双端队列节点的引用(_Deque_Node)
            r - 指向双端队列节点的引用(_Deque_Node)
        -------------------------------------------------------
        返回:
            None
        -------------------------------------------------------
        """
        if l == r:
            return
        
        # 保存l和r的前后节点
        l_prev = l._prev
        l_next = l._next
        r_prev = r._prev
        r_next = r._next
        
        # 处理l和r相邻的情况
        if l_next == r:
            # l在r前面
            l._next = r_next
            l._prev = r
            r._prev = l_prev
            r._next = l
            
            if l_prev is not None:
                l_prev._next = r
            else:
                self._front = r
            
            if r_next is not None:
                r_next._prev = l
            else:
                self._rear = l
        elif r_next == l:
            # r在l前面，调用上面的逻辑交换两者
            self._swap(r, l)
            return
        else:
            # 不相邻的情况，交换指针
            l._prev = r_prev
            l._next = r_next
            r._prev = l_prev
            r._next = l_next
            
            if l_prev is not None:
                l_prev._next = r
            else:
                self._front = r
            
            if l_next is not None:
                l_next._prev = r
            
            if r_prev is not None:
                r_prev._next = l
            else:
                self._front = l
            
            if r_next is not None:
                r_next._prev = l
            
            # 更新队尾
            if l == self._rear:
                self._rear = r
            elif r == self._rear:
                self._rear = l
        return

    def __iter__(self):
        """
        仅用于测试
        -------------------------------------------------------
        生成Python迭代器，从队列前端到后端遍历元素
        使用: for v in d:
        -------------------------------------------------------
        返回:
            yields - 队列中的下一个元素(任意类型)
        -------------------------------------------------------
        """
        current = self._front
        while current is not None:
            yield current._value
            current = current._next

内容的提问来源于stack exchange，提问作者ACR