perf(link): optimize concurrent response (#641)

* fix(crypt): bug caused by link cache

* perf(crypt,mega,halalcloud,quark,uc): optimize concurrent response link

* chore: 删除无用代码

* ftp

* 修复bug；资源释放

* 添加SyncClosers

* local,sftp,smb

* 重构，优化，增强

* Update internal/stream/util.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Signed-off-by: j2rong4cn <36783515+j2rong4cn@users.noreply.github.com>

* chore

* chore

* 优化，修复bug

* .

---------

Signed-off-by: j2rong4cn <36783515+j2rong4cn@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

pkg/singleflight/singleflight.go

@@ -73,6 +73,8 @@ type call[T any] struct {
 type Group[T any] struct {
 	mu sync.Mutex          // protects m
 	m  map[string]*call[T] // lazily initialized
+
+	Remember bool
 }
 
 // Result holds the results of Do, so they can be passed
@@ -156,7 +158,7 @@ func (g *Group[T]) doCall(c *call[T], key string, fn func() (T, error)) {
 		g.mu.Lock()
 		defer g.mu.Unlock()
 		c.wg.Done()
-		if g.m[key] == c {
+		if !g.Remember && g.m[key] == c {
 			delete(g.m, key)
 		}
 

pkg/singleflight/var.go

@@ -0,0 +1,3 @@
+package singleflight
+
+var ErrorGroup Group[error]

pkg/utils/io.go

@@ -153,46 +153,99 @@ func Retry(attempts int, sleep time.Duration, f func() error) (err error) {
 type ClosersIF interface {
 	io.Closer
 	Add(closer io.Closer)
-	TryAdd(reader io.Reader)
-	AddClosers(closers Closers)
-	GetClosers() Closers
+	AddIfCloser(a any)
 }
+type Closers []io.Closer
 
-type Closers struct {
-	closers []io.Closer
+func (c *Closers) Close() error {
+	var errs []error
+	for _, closer := range *c {
+		if closer != nil {
+			errs = append(errs, closer.Close())
+		}
+	}
+	*c = (*c)[:0]
+	return errors.Join(errs...)
 }
-
-func (c *Closers) GetClosers() Closers {
-	return *c
+func (c *Closers) Add(closer io.Closer) {
+	if closer != nil {
+		*c = append(*c, closer)
+	}
+}
+func (c *Closers) AddIfCloser(a any) {
+	if closer, ok := a.(io.Closer); ok {
+		*c = append(*c, closer)
+	}
 }
 
 var _ ClosersIF = (*Closers)(nil)
 
-func (c *Closers) Close() error {
+func NewClosers(c ...io.Closer) Closers {
+	return Closers(c)
+}
+
+type SyncClosersIF interface {
+	ClosersIF
+	AcquireReference() bool
+}
+
+type SyncClosers struct {
+	closers []io.Closer
+	mu      sync.Mutex
+	ref     int
+}
+
+var _ SyncClosersIF = (*SyncClosers)(nil)
+
+func (c *SyncClosers) AcquireReference() bool {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if len(c.closers) == 0 {
+		return false
+	}
+	c.ref++
+	log.Debugf("SyncClosers.AcquireReference %p,ref=%d\n", c, c.ref)
+	return true
+}
+
+func (c *SyncClosers) Close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	defer log.Debugf("SyncClosers.Close %p,ref=%d\n", c, c.ref)
+	if c.ref > 1 {
+		c.ref--
+		return nil
+	}
+	c.ref = 0
+
 	var errs []error
 	for _, closer := range c.closers {
 		if closer != nil {
 			errs = append(errs, closer.Close())
 		}
 	}
+	c.closers = c.closers[:0]
 	return errors.Join(errs...)
 }
-func (c *Closers) Add(closer io.Closer) {
+
+func (c *SyncClosers) Add(closer io.Closer) {
 	if closer != nil {
+		c.mu.Lock()
 		c.closers = append(c.closers, closer)
-	}
-}
-func (c *Closers) AddClosers(closers Closers) {
-	c.closers = append(c.closers, closers.closers...)
-}
-func (c *Closers) TryAdd(reader io.Reader) {
-	if closer, ok := reader.(io.Closer); ok {
-		c.closers = append(c.closers, closer)
+		c.mu.Unlock()
 	}
 }
 
-func NewClosers(c ...io.Closer) Closers {
-	return Closers{c}
+func (c *SyncClosers) AddIfCloser(a any) {
+	if closer, ok := a.(io.Closer); ok {
+		c.mu.Lock()
+		c.closers = append(c.closers, closer)
+		c.mu.Unlock()
+	}
+}
+
+func NewSyncClosers(c ...io.Closer) SyncClosers {
+	return SyncClosers{closers: c}
 }
 
 type Ordered interface {