小编Sri*_*har的帖子

Files.walkFileTree访问同一级别的文件/目录的顺序是什么？

它似乎没有按大小,上次修改时间或名称的顺序访问它们.我在API文档中也找不到任何内容.

也许该preVisitDirectory方法可用于指定访问顺序,但默认行为是什么？

我知道goroutine被多路复用到多个OS线程上,因此如果应该阻塞,例如在等待I/O时,其他人继续运行.但有没有办法提前知道如果我要创建n个goroutines我会产生多少个线程？

例如,如果我们调用下面的函数,我们就知道将为n个goroutines创建多少(或最大数量)系统线程:

type Vector []float64

// Apply the operation to n elements of v starting at i.
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
    for ; i < n; i++ {
        v[i] += u.Op(v[i])
    }
    c <- 1;    // signal that this piece is done
}

根据我的理解,servlet容器创建有限的servlet实例和每个servlet实例的多个线程,并重用这些线程和实例.

因为有多个线程实例,所以它们不是"线程安全的"(虽然我知道使用Thread-safety编写它们并不困难).

另一方面,EJB容器不创建EJB的线程,而是仅重用EJB对象(使用池).由于EJB实例没有多个线程,因此不存在线程安全问题.

我的问题:为什么有不同的行为？将EJB作为Servlet(线程不安全)工作不是一个好主意吗？

我确定我错过了一些东西,并希望了解那个缺失的部分.

在以下代码中,两个选项似乎都分配了相同的资源

func Allocate(v interface{}) error {
    rv := reflect.ValueOf(v)
    if rv.IsNil() {
        return errors.New("Value of v is nil")
    }
    s0 := reflect.New(rv.Type().Elem())
    s1 := reflect.New(rv.Elem().Type())

    return errors.New(fmt.Sprintf("What's the diff? %v %v", s0, s1))
}

如果这个具体例子没有区别,那么说明差异的例子就会很棒.此外,在尝试分配接口时,此特定情况下的首选选项是什么.

编辑:reflect.DeepEqual(s0,s1)返回false.我认为rv.Elem().Type()有一个处理零值的问题,所以可能是rv.Type().Elem()是首选.

操场

虽然输入类似，但 URL.RawQuery 似乎已正确填充。

操场

u, err := url.Parse("https://example.com/foo%2fbar")
if err != nil {
    log.Fatal(err)
}
fmt.Println(u.Path)
fmt.Println(u.RawPath)
fmt.Println(u.String(), "\n")

u, err = url.Parse("https://example.com/foo%25fbar?q=morefoo%25bar")
if err != nil {
    log.Fatal(err)
}
fmt.Println(u.Path)
fmt.Println(u.RawPath)
fmt.Println(u.RawQuery)
fmt.Println(u.String())

在有效的 Go文档中指出：

正如我们在 ByteSize 中看到的，可以为任何命名类型定义方法（指针除外......

type ByteSlice []byte
func (slice ByteSlice) Append(data []byte) []byte {
  // Body exactly the same as above
}

然后它继续提供一个以指针作为接收器的示例：

func (p *ByteSlice) Append(data []byte) {
  slice := *p
  // Body as above, without the return.
  *p = slice
}

这不矛盾吗？或者这是否意味着这是无效的：

type ByteSlice []byte
type Pb *ByteSlice
func (p Pb) Append(data []byte) []byte {
} 

虽然它看起来就像一个 typedef！

如果编译器可以识别导入未使用,那么是否可以将其设置为在没有导入的情况下继续编译？

即使不可能,这种选择的优点/缺点是什么？

以下代码有时输出2.为什么等待组没有等待所有goroutine完成？

type Scratch struct {
    //sync.RWMutex
    Itch []int
}

func (s *Scratch) GoScratch(done chan bool, j int) error {

    var ws sync.WaitGroup

    if len(s.Itch) == 0 {
            s.Rash = make([]int, 0)
    }
    for i := 0; i < j; i++ {
            ws.Add(1)
            go func (i int) {
                    defer ws.Done()

                   s.Rash = append(s.Rash, i) 
            }(i)
    }
    ws.Wait()
    done<- true
    return nil
}

func main() {
    done := make(chan bool, 3)
    s := &Scratch{}
    err := s.GoScratch(done, 3)
    if err != nil …

我有一个功能。

func doSome(v interface{}) {\n\n}  \n

如果我通过指针将结构体切片传递到函数中，则函数必须填充该切片。

type Color struct {\n}\ntype Brush struct {\n}\n\nvar c []Color\ndoSome(&c) // after \xd1\x81 is array contains 3 elements type Color\n\nvar b []Brush\ndoSome(&b) // after b is array contains 3 elements type Brush\n

也许我需要使用反射，但是如何呢？

从Effective Go开始

接收器始终阻塞,直到有数据要接收.如果通道未缓冲,则发送方将阻塞,直到接收方收到该值.

但signal.Notify将信号中继到无缓冲信道而不会阻塞.这是如何工作的,是否可以与其他陈< - 类型一起使用？

我有一个Runnable，它从如下所示的连接池中获得连接，并有60秒的时间对连接进行处理：

private static ConnectionPoolDataSource cpds; // MysqlConnectionPoolDataSource

public void run(){
    while((System.currentTimeMillis()-created)<60000){
        try(Connection conn = cpds.getPooledConnection().getConnection()){  
            //do something
        }catch(SQLException sqle){}
    }
}

当线程在60s之后死掉时，我假设连接将返回到池中，并且当创建新线程时，可以重新使用该连接。但是，当我列出我的网络连接时，随着创建更多线程，列表会不断增长。如上创建的连接是否可以正确返回到池中，如果可以，我如何强制重新使用连接？

除非包中的所有测试都通过，否则基准测试是否预计不会运行？

我查看了测试包文档和测试标志，但找不到记录表明基准测试仅在所有测试通过后运行。

即使包中的某些测试失败，是否有办法强制基准测试函数运行？