我在Python中有这个方便的功能:
def follow(path):
with open(self.path) as lines:
lines.seek(0, 2) # seek to EOF
while True:
line = lines.readline()
if not line:
time.sleep(0.1)
continue
yield line
它与UNIX类似tail -f:您可以获得文件的最后一行.它很方便,因为您可以在不阻塞的情况下获取生成器并将其传递给另一个函数.
然后我不得不在Go做同样的事情.我是这种语言的新手,所以我不确定我所做的是否是惯用/正确的Go.
这是代码:
func Follow(fileName string) chan string {
out_chan := make(chan string)
file, err := os.Open(fileName)
if err != nil {
log.Fatal(err)
}
file.Seek(0, os.SEEK_END)
bf := bufio.NewReader(file)
go func() {
for {
line, _, _ := bf.ReadLine()
if len(line) == 0 {
time.Sleep(10 * time.Millisecond)
} …我有一台机器有24个物理核心(至少我被告知)运行Debian : Linux 3.2.0-4-amd64 #1 SMP Debian 3.2.68-1+deb7u1 x86_64 GNU/Linux. 这似乎是正确的:
usr@machine:~/$ cat /proc/cpuinfo | grep processor
processor : 0
processor : 1
<...>
processor : 22
processor : 23
我试图用Python加载所有内核时遇到了一些问题multiprocessing.pool.Pool.我用过Pool(processes=None); 文档说Python使用cpu_count()if None提供.
唉,只有8个核心100%加载,其他核心闲置(我用来htop监控CPU负载).我以为我无法正常烹饪Pools并尝试"手动"调用24个进程:
print 'Starting processes...'
procs = list()
for param_set in all_params: # 24 items
p = Process(target=_wrap_test, args=[param_set])
p.start()
procs.append(p)
print 'Now waiting for them.'
for p in procs: …上周五我参加了面试,不得不回答以下问题:为什么这段代码会引发异常(UnboundLocalError: local variable 'var' referenced before assignment在包含的行上var += 1)？
def outer():
var = 1
def inner():
var += 1
return var
return inner
我无法给出正确答案; 这个事实让我心烦意乱,当我回到家时,我很难找到合适的答案.好吧,我已经找到了答案,但现在有别的东西,让我困惑.
我必须事先说,我的问题更多的是关于设计语言时做出的决定,而不是关于它是如何工作的.
所以,请考虑这段代码.内部函数是一个python闭包,var并不是本地的outer- 它存储在一个单元格中(然后从单元格中检索):
def outer():
var = 1
def inner():
return var
return inner
反汇编看起来像这样:
0 LOAD_CONST 1 (1)
3 STORE_DEREF 0 (var) # not STORE_FAST
6 LOAD_CLOSURE 0 (var)
9 BUILD_TUPLE 1
12 LOAD_CONST 2 (<code object inner at 0x10796c810)
15 LOAD_CONST 3 …我需要你的智慧.
我有一个用Go写的巨大守护进程.前段时间,用户报告代码中某处可能存在内存泄漏.
我开始调查这个问题.当主要代码检查没有让我得到关于泄漏性质的任何线索时,我试着关注我的过程如何工作.
我的想法很简单:如果我没有删除对某些对象的引用,我的堆应该不断增长.我编写了以下过程来监视堆:
func PrintHeap() {
ticker := time.NewTicker(time.Second * 5)
for {
<-ticker.C
st := &runtime.MemStats{}
runtime.ReadMemStats(st)
// From Golang docs: HeapObjects increases as objects are allocated
// and decreases as the heap is swept and unreachable objects are
// freed.
fmt.Println("Heap allocs:", st.Mallocs, "Heap frees:",
st.Frees, "Heap objects:", st.HeapObjects)
}
}
此过程每5秒打印一些有关堆的信息,包括当前分配的对象数.
现在谈谈守护进程的作用.它处理来自某些UDP输入的行.每行都包含有关某个HTTP请求的一些信息,并被解析为典型的Go结构.此结构具有一些数字和字符串字段,包括一个用于请求路径.然后这个结构发生了很多事情,但这些事情在这里是无关紧要的.
现在,我将输入速率设置为每秒1500行,每行都相当短(您可以将其读作:使用标准请求路径/).
运行应用程序后,我可以看到堆大小在某个时间点稳定:
Heap allocs: 180301314 Heap frees: 175991675 Heap objects: 4309639
Heap allocs: 180417372 Heap frees: 176071946 Heap objects: 4345426
Heap allocs: …假设我在包中有一个MyType带私有方法的类型.我还有一个目录,我想在那里存储我的包的测试.这是看起来像:(mt *MyType) private()mypackageteststests/mypackage_test.go
package mypackage_test
import (
"testing"
"myproj/mypackage"
)
func TestPrivate(t *testing.T) {
// Some test code
}
但是,当我运行时,go test我得到了cannot refer to unexported field or method my package.(*MyType)."".private)错误.我已经google了一下,发现从小写开始的函数不能在他们自己的包之外看到(这似乎是真的,因为大写函数可以从测试中自由调用).
我还读到了某个地方,添加<...>_internal_test.go到测试文件可以解决我的问题,如this(tests/mypackage_internal_test.go):
package mypackage
import (
"testing"
)
func TestPrivate(t *testing.T) {
mt := &MyType{}
// Some test code
}
但有了这个,我才得到undefined: MyType.所以,我的问题是:我如何测试内部/私有方法？
Go中的某些类型是引用类型：映射，切片，通道，函数和方法。
有时您需要使用指向引用的指针。例如，
type Stack []interface{}
func (stack *Stack) Push(x interface{}) {
*stack = append(*stack, x)
}
之所以需要它，是因为所有参数都是通过复制值来传递的，并且append()可能需要在分片的容量不够大的情况下重新分配内存。我明白了。
第一个问题。怎么样map的类型？如果我有一个基于的自定义类型map，如果预期会发生一些key：value插入或删除操作，我是否最好始终传递一个指向它的指针？
第二个问题。那其他参考类型呢？Channel， 例如。我可以想象这样一种情况，我将基于通道构建自定义类型，以对传递到通道的值实施一些自定义预处理。这里也需要指针吗？
抱歉，这是基本知识，但是我真的想很好地理解这个主题。
这是有效的代码：
package main
import (
"fmt"
)
type Base struct {
Field int
}
type Derived struct {
Base
}
func main() {
d := &Derived{}
d.Field = 10
fmt.Println(d.Field)
}
这是无法编译的代码 ./main.go:17: unknown Derived field 'Field' in struct literal
package main
import (
"fmt"
)
type Base struct {
Field int
}
type Derived struct {
Base
}
func main() {
d := &Derived{
Field: 10,
}
fmt.Println(d.Field)
}
这到底是怎么回事？抱歉，很明显，但是我不明白。