diff --git a/transport/internet/finalmask/noise/conn.go b/transport/internet/finalmask/noise/conn.go
index c3ab89ab..8bb115bb 100644
--- a/transport/internet/finalmask/noise/conn.go
+++ b/transport/internet/finalmask/noise/conn.go
@@ -12,85 +12,41 @@ type noiseConn struct {
 	net.PacketConn
 	config *Config
 	m      map[string]time.Time
-	stop   chan struct{}
-	once   sync.Once
-	mutex  sync.RWMutex
+	mu     sync.Mutex
 }
 
 func NewConnClient(c *Config, raw net.PacketConn) (net.PacketConn, error) {
-	conn := &noiseConn{
+	return &noiseConn{
 		PacketConn: raw,
 		config:     c,
 		m:          make(map[string]time.Time),
-		stop:       make(chan struct{}),
-	}
-
-	if conn.config.ResetMax > 0 {
-		go conn.reset()
-	}
-
-	return conn, nil
+	}, nil
 }
 
 func NewConnServer(c *Config, raw net.PacketConn) (net.PacketConn, error) {
 	return NewConnClient(c, raw)
 }
 
-func (c *noiseConn) reset() {
-	ticker := time.NewTicker(1 * time.Second)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ticker.C:
-			c.mutex.RLock()
-			now := time.Now()
-			timeOut := make([]string, 0, len(c.m))
-			for key, last := range c.m {
-				if now.After(last) {
-					timeOut = append(timeOut, key)
-				}
-			}
-			c.mutex.RUnlock()
-
-			for _, key := range timeOut {
-				c.mutex.Lock()
-				delete(c.m, key)
-				c.mutex.Unlock()
-			}
-		case <-c.stop:
-			return
-		}
-	}
-}
-
 func (c *noiseConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
-	c.mutex.RLock()
-	_, ready := c.m[addr.String()]
-	c.mutex.RUnlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 
-	if !ready {
-		c.mutex.Lock()
-		_, ready = c.m[addr.String()]
-		if !ready {
-			for _, item := range c.config.Items {
-				if item.RandMax > 0 {
-					item.Packet = make([]byte, crypto.RandBetween(item.RandMin, item.RandMax))
-					crypto.RandBytesBetween(item.Packet, byte(item.RandRangeMin), byte(item.RandRangeMax))
-				}
+	t := c.m[addr.String()]
+
+	if t.IsZero() || (c.config.ResetMax > 0 && time.Now().After(t)) {
+		for _, item := range c.config.Items {
+			if item.RandMax > 0 {
+				buf := make([]byte, crypto.RandBetween(item.RandMin, item.RandMax))
+				crypto.RandBytesBetween(buf, byte(item.RandRangeMin), byte(item.RandRangeMax))
+				c.PacketConn.WriteTo(buf, addr)
+			} else {
 				c.PacketConn.WriteTo(item.Packet, addr)
-				time.Sleep(time.Duration(crypto.RandBetween(item.DelayMin, item.DelayMax)) * time.Millisecond)
 			}
-			c.m[addr.String()] = time.Now().Add(time.Duration(crypto.RandBetween(c.config.ResetMin, c.config.ResetMax)) * time.Second)
+			time.Sleep(time.Duration(crypto.RandBetween(item.DelayMin, item.DelayMax)) * time.Millisecond)
 		}
-		c.mutex.Unlock()
 	}
 
+	c.m[addr.String()] = time.Now().Add(time.Duration(crypto.RandBetween(c.config.ResetMin, c.config.ResetMax)) * time.Second)
+
 	return c.PacketConn.WriteTo(p, addr)
 }
-
-func (c *noiseConn) Close() error {
-	c.once.Do(func() {
-		close(c.stop)
-	})
-	return c.PacketConn.Close()
-}