Description:
a dubbo provider project with springboot invokes dubbo service, defining referenced service like this:
```
 @DubboReference( check = false,url = "tri://localhost:50051")
 private HelloService helloService;
```

The consumer repeatedly calls the service with a delay of one second after each call.
```
 @Scheduled(fixedDelay = 1000)
    public void run() {
        String message = helloService.sayHello("lucky");
        System.out.println(message);
    }
```
key config items in  application.properties like this :
```
 dubbo.registry.address: N/A
```

Question:
The above code can run normally in dubbo-3.1.7, when starting the service consumer first, and then starting the service provider. At 3.2.1, the service consumer could not successfully reconnect to the service provider. 
According to the source code, the implementation of the ConnectionListener class, which is responsible for reconnecting, has changed. The number of connection references in the code changed from positive to 0, causing the logic to terminate early. Why is that？

Partial Code of Reconnection:



private static final ErrorTypeAwareLogger logger = LoggerFactory.getErrorTypeAwareLogger(AbstractConnectionClient.class);
    protected WireProtocol protocol;
    protected InetSocketAddress remote;
    protected AtomicBoolean init;
    protected static final Object CONNECTED_OBJECT = new Object();
    private volatile long counter;
    private static final AtomicLongFieldUpdater<AbstractConnectionClient> COUNTER_UPDATER
            = AtomicLongFieldUpdater.newUpdater(AbstractConnectionClient.class, "counter");
    protected AbstractConnectionClient(URL url, ChannelHandler handler) throws RemotingException {
        super(url, handler);
        COUNTER_UPDATER.set(this, 1L);
    }
    /**
     * Increments the reference count by 1.
     */
    public final AbstractConnectionClient retain() {
        long oldCount = COUNTER_UPDATER.getAndIncrement(this);
        if (oldCount <= 0) {
            COUNTER_UPDATER.getAndDecrement(this);
            throw new AssertionError("This instance has been destroyed");
        }
        return this;
    }
    /**
     * Decreases the reference count by 1 and calls {@link this#destroy} if the reference count reaches 0.
     */
    public final boolean release() {
        long remainingCount = COUNTER_UPDATER.decrementAndGet(this);
        if (remainingCount == 0) {
            destroy();