Простой поток данных: Go работает очень медленно по сравнению с Java ⇐ JAVA

[Anonymous]

Как Java-разработчик, я сейчас рассматриваю Go, потому что считаю это интересным языком.

Для начала я решил взять простой Java проект, который я написал несколько месяцев назад, и переписал его на Go, чтобы сравнить производительность и (в основном, на самом деле) сравнить читаемость/сложность кода.

Пример кода Java — это следующее:

Код: Выделить всё

public static void main(String[] args) {
long start = System.currentTimeMillis();

Stream s = Stream.from(new Iterator() {
int i = 0;

@Override
public boolean hasNext() {
return i < 10000000;
}

@Override
public Container next() {
return new Container(i++);
}
});

s = s.map((Container _source) -> new Container(_source.value * 2));

int j = 0;
while (s.hasNext()) {
s.next();
j++;
}

System.out.println(System.currentTimeMillis() - start);

System.out.println("j:" + j);
}

public static class Container {

int value;

public Container(int v) {
value = v;
}

}

Где находится функция карты:

Код: Выделить всё

return new Stream() {
@Override
public boolean hasNext() {
return Stream.this.hasNext();
}

@Override
public R next() {
return _f.apply(Stream.this.next());
}
};

А класс Stream — это просто расширение java.util.Iterator, позволяющее добавлять к нему собственные методы. Другие методы, кроме карты, отличаются от стандартного API Java Stream.

Во всяком случае, чтобы воспроизвести это, я написал следующий код Go:

Код: Выделить всё

package main

import (
"fmt"
)

type Iterator interface {
HasNext() bool
Next() interface{}
}

type Stream interface {
HasNext() bool
Next() interface{}
Map(transformer func(interface{}) interface{}) Stream
}

///////////////////////////////////////

type incremetingIterator struct {
i int
}

type SampleEntry struct {
value int
}

func (s *SampleEntry) Value() int {
return s.value
}

func (s *incremetingIterator) HasNext() bool {
return s.i < 10000000
}

func (s *incremetingIterator) Next() interface{} {
s.i = s.i + 1
return &SampleEntry{
value: s.i,
}
}

func CreateIterator() Iterator {
return &incremetingIterator{
i: 0,
}
}

///////////////////////////////////////
type stream struct {
source Iterator
}

func (s *stream) HasNext() bool {
return s.source.HasNext()
}

func (s *stream) Next() interface{} {
return s.source.Next()
}

func (s *stream) Map(tr func(interface{}) interface{}) Stream {
return &stream{
source: &mapIterator{
source:      s,
transformer: tr,
},
}
}

func FromIterator(it Iterator) Stream {
return &stream{
source: it,
}
}

///////////////////////////////////////
type mapIterator struct {
source      Iterator
transformer func(interface{}) interface{}
}

func (s *mapIterator) HasNext() bool {
return s.source.HasNext()
}

func (s *mapIterator) Next() interface{} {
return s.transformer(s.source.Next())
}

///////////////////////////////////////
func main() {

it := CreateIterator()

ss := FromIterator(it)

ss = ss.Map(func(in interface{}) interface{} {
return &SampleEntry{
value: 2 * in.(*SampleEntry).value,
}
})

fmt.Println("Start")
for ss.HasNext() {
ss.Next()
}
fmt.Println("Over")
}

Оба дают одинаковый результат, но когда Java занимает около 20 мс, Go — 1050 мс (с 10 миллионами элементов тест выполнялся несколько раз).
Я новичок в Go (начал пару часов назад), поэтому, пожалуйста, будьте снисходительны, если я сделал что-то действительно плохое

Спасибо !

Подробнее здесь: https://stackoverflow.com/questions/428 ... ed-to-java