Method reset

redis/connection.py:3414–3475

(self)

        )

    def reset(self):
        # Create and fill up a thread safe queue with ``None`` values.
        try:
            if self._in_maintenance:
                self._lock.acquire()
                self._locked = True

            # Record metrics for connections being removed before clearing
            # Note: Access pool.queue directly to avoid deadlock since we may
            # already hold self._lock (which is non-reentrant)
            if (
                hasattr(self, "_connections")
                and self._connections
                and hasattr(self, "pool")
            ):
                with self._lock:
                    connections_in_queue = {conn for conn in self.pool.queue if conn}
                    idle_count = len(connections_in_queue)
                    in_use_count = len(self._connections) - idle_count
                    if idle_count > 0 or in_use_count > 0:
                        pool_name = get_pool_name(self)
                        if idle_count > 0:
                            record_connection_count(
                                pool_name=pool_name,
                                connection_state=ConnectionState.IDLE,
                                counter=-idle_count,
                            )
                        if in_use_count > 0:
                            record_connection_count(
                                pool_name=pool_name,
                                connection_state=ConnectionState.USED,
                                counter=-in_use_count,
                            )

            self.pool = self.queue_class(self.max_connections)
            while True:
                try:
                    self.pool.put_nowait(None)
                except Full:
                    break

            # Keep a list of actual connection instances so that we can
            # disconnect them later.
            self._connections = []
        finally:
            if self._locked:
                try:
                    self._lock.release()
                except Exception:
                    pass
                self._locked = False

        # this must be the last operation in this method. while reset() is
        # called when holding _fork_lock, other threads in this process
        # can call _checkpid() which compares self.pid and os.getpid() without
        # holding any lock (for performance reasons). keeping this assignment
        # as the last operation ensures that those other threads will also
        # notice a pid difference and block waiting for the first thread to