refactor!: remove pool and use chan instead

README.md

@@ -110,9 +110,9 @@ import (
 )
 
 func main() {
-	size, err := getFolderSize.Parallel("./") // Concurrent running, invincible fast
+	size, err := getFolderSize.Invoke("./") // Concurrent running, invincible fast
 
-  size2 := getFolderSize.LooseParallel("./") // Sometimes we may encounter inaccessible files, and we can set 'loose' to ignore them
+  size2 := getFolderSize.LooseInvoke("./") // Sometimes we may encounter inaccessible files, and we can set 'loose' to ignore them
 }
 ```
 

README_ZH.md

@@ -89,9 +89,9 @@ import (
 )
 
 func main() {
-	size, err := getFolderSize.Parallel("./") // 并发计算，超级快
+	size, err := getFolderSize.Invoke("./") // 并发计算，超级快
 
-  size2 := getFolderSize.LooseParallel("./") // 有时我们可能会遇到不可访问的文件，我们可以使用 loose 来忽略它们
+  size2 := getFolderSize.LooseInvoke("./") // 有时我们可能会遇到不可访问的文件，我们可以使用 loose 来忽略它们
 }
 ```
 

go.mod

@@ -1,5 +1,3 @@
 module github.com/markthree/go-get-folder-size
 
 go 1.20
-
-require github.com/panjf2000/ants/v2 v2.8.1

main.go

@@ -18,7 +18,7 @@ func fail(base string, err error) {
 }
 
 func handle(base string) {
-	size, err := getFolderSize.Parallel(base)
+	size, err := getFolderSize.Invoke(base)
 
 	if err != nil {
 		fail(base, err)
@@ -29,7 +29,7 @@ func handle(base string) {
 }
 
 func looseHandle(base string) {
-	size := getFolderSize.LooseParallel(base)
+	size := getFolderSize.LooseInvoke(base)
 	success(base, size)
 }
 
@@ -60,10 +60,10 @@ func main() {
 			return
 		}
 		if isLoose {
-			size := getFolderSize.LooseParallel(root)
+			size := getFolderSize.LooseInvoke(root)
 			fmt.Fprint(os.Stdout, size)
 		} else {
-			size, err := getFolderSize.Parallel(root)
+			size, err := getFolderSize.Invoke(root)
 			if err != nil {
 				fmt.Fprint(os.Stderr, err)
 				return

src/core.go

@@ -1,70 +1,70 @@
 package core
 
 import (
-	"fmt"
+	"io/fs"
 	"os"
 	"path"
-	"sync"
-	"sync/atomic"
-
-	"github.com/panjf2000/ants/v2"
 )
 
-var pool, _ = ants.NewPool(1000000, ants.WithPreAlloc(true))
+type EntrySizeChan chan int64
+
+func Invoke(folder string) (size int64, e error) {
+	gracefulExit := func(err error) {
+		e = err
+		size = 0
+	}
 
-func calc(folder string) (total int64, e error) {
 	entrys, err := os.ReadDir(folder)
 	if err != nil {
-		return 0, err
+		gracefulExit(err)
+		return
 	}
 	entrysLen := len(entrys)
 	if entrysLen == 0 {
-		return 0, nil
+		gracefulExit(nil)
+		return
 	}
-	var wg sync.WaitGroup
-	wg.Add(entrysLen)
-
+	errChan := make(chan error)
+	sizeChan := make(EntrySizeChan, entrysLen)
 	for i := 0; i < entrysLen; i++ {
-		entry := entrys[i]
-		pool.Submit(func() {
-			defer wg.Done()
+		go func(entry fs.DirEntry) {
 			if entry.IsDir() {
-				size, err := calc(path.Join(folder, entry.Name()))
+				subFolderSize, err := Invoke(path.Join(folder, entry.Name()))
 				if err != nil {
-					panic(err)
+					gracefulExit(err)
+					errChan <- err
+					return
 				}
-				atomic.AddInt64(&total, size)
+				sizeChan <- subFolderSize
 				return
 			}
-			// Normal files
+
 			info, err := entry.Info()
 			if err != nil {
-				panic(err)
+				gracefulExit(err)
+				errChan <- err
+				return
 			}
-			atomic.AddInt64(&total, info.Size())
-		})
+			sizeChan <- info.Size()
+		}(entrys[i])
 	}
-	wg.Wait()
-	return total, nil
-}
 
-// Parallel execution, fast enough
-func Parallel(folder string) (total int64, e error) {
-	// catch panic
-	defer func() {
-		if err := recover(); err != nil {
-			e = fmt.Errorf("%v", err)
+	for i := 0; i < entrysLen; i++ {
+		select {
+		case nestedErr := <-errChan:
+			gracefulExit(nestedErr)
+			return
+		case nestedSize := <-sizeChan:
+			size += nestedSize
 		}
-	}()
-
-	total, err := calc(folder)
-	if err != nil {
-		return 0, err
 	}
-	return total, nil
+
+	return size, e
 }
 
-func looseCalc(folder string) (total int64) {
+func LooseInvoke(folder string) int64 {
+	size := int64(0)
+
 	entrys, err := os.ReadDir(folder)
 	if err != nil {
 		return 0
@@ -73,29 +73,25 @@ func looseCalc(folder string) (total int64) {
 	if entrysLen == 0 {
 		return 0
 	}
-	var wg sync.WaitGroup
-	wg.Add(entrysLen)
-
+	sizeChan := make(EntrySizeChan, entrysLen)
 	for i := 0; i < entrysLen; i++ {
-		entry := entrys[i]
-		pool.Submit(func() {
-			defer wg.Done()
+		go func(entry fs.DirEntry) {
 			if entry.IsDir() {
-				size := looseCalc(path.Join(folder, entry.Name()))
-				atomic.AddInt64(&total, size)
+				subFolderSize := LooseInvoke(path.Join(folder, entry.Name()))
+				sizeChan <- subFolderSize
 				return
 			}
-			// Normal files
 			info, err := entry.Info()
-			if err == nil {
-				atomic.AddInt64(&total, info.Size())
+			if err != nil {
+				sizeChan <- 0
+				return
 			}
-		})
+			sizeChan <- info.Size()
+		}(entrys[i])
 	}
-	wg.Wait()
-	return total
-}
 
-func LooseParallel(folder string) (total int64) {
-	return looseCalc(folder)
+	for i := 0; i < entrysLen; i++ {
+		size += <-sizeChan
+	}
+	return size
 }

wasm/main.go

@@ -13,10 +13,10 @@ func main() {
 	isLoose := os.Getenv("loose") == "true"
 
 	if isLoose {
-		value := getFolderSize.LooseParallel(base)
+		value := getFolderSize.LooseInvoke(base)
 		js.Global().Set("$folderSize", value)
 	} else {
-		value, err := getFolderSize.Parallel(base)
+		value, err := getFolderSize.Invoke(base)
 
 		if err != nil {
 			js.Global().Set("$folderSizeError", err)