Java, Rust и Go в системном программировании - Сравнительный анализ

// Go использует GC, но с ценными оптимизациями и анализом "утечек"
func processData(data []byte) ([]byte, error) {
    // Проще, чем Rust, но с возможными GC-паузами
    return transform(data)
}

for i := 0; i < 1000000; i++ {
    go func(id int) {
        // Горутины значительно легче, чем OS-потоки
        results <- processRequest(id)
    }(i)
}

// В Go чаще всего не думаешь о памяти, а используешь простые абстракции
var cache = sync.Map{}
go func() {
    for {
        // Сборщик мусора сам очистит старые элементы
        cache.Range(func(key, value interface{}) bool {
            entry := value.(*CacheEntry)
            if entry.expired() {
                cache.Delete(key)
            }
            return true
        })
        time.Sleep(time.Minute)
    }
}()

// Явная обработка ошибок в Go
user, err := userRepository.FindById(id)
if err != nil {
    log.Printf("Ошибка поиска пользователя: %v", err)
    return
}
fmt.Println("Username:", user.Username)

// Параллельные HTTP-запросы на Go 
func fetchAll() error {
    var wg sync.WaitGroup
    urls := []string{
        "https://api.example.com/users",
        "https://api.example.com/products",
    }
    
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            resp, err := http.Get(url)
            if err != nil {
                log.Printf("Ошибка при запросе %s: %v", url, err)
                return
            }
            defer resp.Body.Close()
            // Обработка ответа
        }(url)
    }
    
    wg.Wait()
    return nil
}

// Пример Go-кода из системы потоковой передачи (упрощенно)
func streamHandler(w http.ResponseWriter, r *http.Request) {
   // Устанавливаем заголовки для стриминга
   w.Header().Set("Content-Type", "video/mp4")
   w.Header().Set("Transfer-Encoding", "chunked")
   
   // Открываем доступ к видеофайлу
   videoFile, err := os.Open(videoPath)
   if err != nil {
       http.Error(w, "Файл недоступен", http.StatusInternalServerError)
       return
   }
   defer videoFile.Close()
   
   buffer := make([]byte, 64*1024) // 64KB буфер
   for {
       // Читаем порцию данных
       n, err := videoFile.Read(buffer)
       if err == io.EOF {
           break
       }
       // Отправляем порцию клиенту
       w.Write(buffer[:n])
       // Сбрасываем буфер, чтобы клиент получил данные немедленно
       if f, ok := w.(http.Flusher); ok {
           f.Flush()
       }
   }
}

// Горутины прекрасно масштабируются для сбора метрик
func collectMetrics(servers []Server) {
    results := make(chan ServerMetrics, len(servers))
    
    // Запускаем горутину для каждого сервера
    for _, server := range servers {
        go func(s Server) {
            metrics, err := fetchMetrics(s)
            if err != nil {
                log.Printf("Ошибка сбора метрик с %s: %v", s.Name, err)
                results <- ServerMetrics{Server: s, Error: err}
                return
            }
            results <- ServerMetrics{Server: s, Data: metrics}
        }(server)
    }
    
    // Собираем результаты
    for i := 0; i < len(servers); i++ {
        result := <-results
        processMetrics(result)
    }
}

// Пример кода из сервиса обработки платежей (упрощённо)
func ProcessPayment(ctx context.Context, payment *Payment) (*Transaction, error) {
    // Создаём уникальный идентификатор транзакции
    txID := uuid.New().String()
    
    // Валидируем платёжные данные
    if err := validatePayment(payment); err != nil {
        metrics.IncCounter("payment.validation.error")
        return nil, fmt.Errorf("validation failed: %w", err)
    }
    
    // Проверка на мошенничество
    risk, err := riskEngine.EvaluateRisk(ctx, payment)
    if err != nil {
        return nil, fmt.Errorf("risk evaluation failed: %w", err)
    }
    
    if risk.Score > riskThreshold {
        metrics.IncCounter("payment.risk.rejected")
        return nil, ErrHighRisk
    }
    
    // Фактическая обработка через платёжный шлюз
    tx, err := paymentGateway.Charge(ctx, payment)
    if err != nil {
        return nil, fmt.Errorf("gateway error: %w", err)
    }
    
    // Сохраняем запись о трансакции
    tx.ID = txID
    if err := db.SaveTransaction(ctx, tx); err != nil {
        // Платёж прошёл, но запись не сохранилась - нужно обработать
        go handleInconsistency(tx)
        return tx, nil // Возвращаем успешный результат клиенту
    }
    
    return tx, nil
}

// Типичный REST API на Go создается за считанные часы
func main() {
    router := mux.NewRouter()
    
    // Минимум кода для готового ендпоинта
    router.HandleFunc("/api/v1/orders", createOrderHandler).Methods("POST")
    
    // Прозрачная интеграция с middleware
    router.Use(authMiddleware, loggingMiddleware)
    
    log.Fatal(http.ListenAndServe(":8080", router))
}

// Даже junior понимает, что происходит
type Order struct {
    ID      string    [INLINE]json:"id"[/INLINE]
    Amount  float64   [INLINE]json:"amount"[/INLINE]
    Created time.Time `json:"created"`
}
 
// Простая передача структуры в JSON без лишних конвертаций
func handleGetOrder(w http.ResponseWriter, r *http.Request) {
    id := mux.Vars(r)["id"]
    order, err := db.FindOrder(id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }
    json.NewEncoder(w).Encode(order)
}

// Go делает сетевое программирование неожиданно простым
func fetchAllUserData(users []User) []UserData {
    var wg sync.WaitGroup
    userDataChan := make(chan UserData, len(users))
    
    for _, user := range users {
        wg.Add(1)
        go func(u User) {
            defer wg.Done()
            data, err := fetchUserData(u.ID)
            if err != nil {
                log.Printf("Ошибка получения данных для %s: %v", u.ID, err)
                return
            }
            userDataChan <- data
        }(user)
    }
    
    go func() {
        wg.Wait()
        close(userDataChan)
    }()
    
    var results []UserData
    for data := range userDataChan {
        results = append(results, data)
    }
    return results
}