WIP(x/net/http/client): Mutiple eventLoop

go.mod

@@ -3,7 +3,7 @@ module github.com/goplus/llgoexamples
 go 1.20
 
 require (
-	github.com/goplus/llgo v0.9.7-0.20240830010153-2434fd778f0b
+	github.com/goplus/llgo v0.9.8-0.20240919105235-c6436ea6d196
 	golang.org/x/net v0.28.0
 )
 

go.sum

@@ -1,5 +1,5 @@
-github.com/goplus/llgo v0.9.7-0.20240830010153-2434fd778f0b h1:iC0vVA8F2DNJ9wVyHI9fP9U0nM+si3LSQJ1TtGftXyo=
-github.com/goplus/llgo v0.9.7-0.20240830010153-2434fd778f0b/go.mod h1:5Fs+08NslqofJ7xtOiIXugkurYOoQvY02ZkFNWA1uEI=
+github.com/goplus/llgo v0.9.8-0.20240919105235-c6436ea6d196 h1:LckJktvgChf3x0eex+GT//JkYRj1uiT4uMLzyrg3ChU=
+github.com/goplus/llgo v0.9.8-0.20240919105235-c6436ea6d196/go.mod h1:5Fs+08NslqofJ7xtOiIXugkurYOoQvY02ZkFNWA1uEI=
 golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE=
 golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg=
 golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=

x/net/http/_demo/parallelRequest/parallelRequest.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/goplus/llgoexamples/x/net/http"
+)
+
+func worker(id int, wg *sync.WaitGroup) {
+	defer wg.Done()
+	resp, err := http.Get("http://www.baidu.com")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(id, ":", resp.Status)
+	//body, err := io.ReadAll(resp.Body)
+	//if err != nil {
+	//	fmt.Println(err)
+	//	return
+	//}
+	//fmt.Println(string(body))
+	resp.Body.Close()
+}
+
+func main() {
+	var wait sync.WaitGroup
+	for i := 0; i < 500; i++ {
+		wait.Add(1)
+		go worker(i, &wait)
+	}
+	wait.Wait()
+	fmt.Println("All done")
+
+	resp, err := http.Get("http://www.baidu.com")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(resp.Status)
+	resp.Body.Close()
+}

x/net/http/bodyChunk.go

@@ -2,73 +2,49 @@ package http
 
 import (
 	"errors"
-	"io"
-	"sync"
 
 	"github.com/goplus/llgo/c/libuv"
 )
 
-type onceError struct {
-	sync.Mutex
-	err error
-}
-
-func (a *onceError) Store(err error) {
-	a.Lock()
-	defer a.Unlock()
-	if a.err != nil {
-		return
-	}
-	a.err = err
-}
-
-func (a *onceError) Load() error {
-	a.Lock()
-	defer a.Unlock()
-	return a.err
-}
-
-func newBodyChunk(asyncHandle *libuv.Async) *bodyChunk {
-	return &bodyChunk{
-		readCh:      make(chan []byte, 1),
-		done:        make(chan struct{}),
-		asyncHandle: asyncHandle,
-	}
-}
-
 type bodyChunk struct {
 	chunk       []byte
 	readCh      chan []byte
 	asyncHandle *libuv.Async
 
-	once sync.Once
 	done chan struct{}
 
-	rerr onceError
+	rerr error
 }
 
 var (
 	errClosedBodyChunk = errors.New("bodyChunk: read/write on closed body")
 )
 
+func newBodyChunk(asyncHandle *libuv.Async) *bodyChunk {
+	return &bodyChunk{
+		readCh:      make(chan []byte, 1),
+		done:        make(chan struct{}),
+		asyncHandle: asyncHandle,
+	}
+}
+
 func (bc *bodyChunk) Read(p []byte) (n int, err error) {
+	select {
+	case <-bc.done:
+		err = bc.readCloseError()
+		return
+	default:
+	}
+
 	for n < len(p) {
 		if len(bc.chunk) == 0 {
+			bc.asyncHandle.Send()
 			select {
-			case chunk, ok := <-bc.readCh:
-				if !ok {
-					if n > 0 {
-						return n, nil
-					}
-					return 0, bc.readCloseError()
-				}
+			case chunk := <-bc.readCh:
 				bc.chunk = chunk
-				bc.asyncHandle.Send()
 			case <-bc.done:
-				if n > 0 {
-					return n, nil
-				}
-				return 0, io.EOF
+				err = bc.readCloseError()
+				return
 			}
 		}
 
@@ -77,28 +53,28 @@ func (bc *bodyChunk) Read(p []byte) (n int, err error) {
 		bc.chunk = bc.chunk[copied:]
 	}
 
-	return n, nil
+	return
 }
 
 func (bc *bodyChunk) Close() error {
-	return bc.closeRead(nil)
+	return bc.closeWithError(nil)
 }
 
 func (bc *bodyChunk) readCloseError() error {
-	if rerr := bc.rerr.Load(); rerr != nil {
+	if rerr := bc.rerr; rerr != nil {
 		return rerr
 	}
 	return errClosedBodyChunk
 }
 
-func (bc *bodyChunk) closeRead(err error) error {
+func (bc *bodyChunk) closeWithError(err error) error {
+	if bc.rerr != nil {
+		return nil
+	}
 	if err == nil {
-		err = io.EOF
+		err = errClosedBodyChunk
 	}
-	bc.rerr.Store(err)
-	bc.once.Do(func() {
-		close(bc.done)
-	})
-	//close(bc.done)
+	bc.rerr = err
+	close(bc.done)
 	return nil
 }