Jak zapewnić zapobieganie przekroczeniu limitu deskryptorów plików otwartych w systemie?

Aby zapobiec przekroczeniu limitu otwartych deskryptorów plików w systemie w Go, można zastosować kilka podejść:

1. Ograniczenie liczby jednocześnie otwartych plików — zaimplementować pulę deskryptorów lub semafor, który kontroluje liczbę otwartych plików.

2. Zamykanie plików zaraz po użyciu — zawsze wywoływać file.Close() w defer zaraz po otwarciu pliku, aby zapewnić zwolnienie zasobów.

3. Sprawdzanie i zwiększanie limitów systemu operacyjnego — za pomocą wywołań systemowych (np. ulimit w Unix) można zwiększyć maksymalną dozwoloną liczbę otwartych plików.

Przykład użycia semafora do ograniczenia otwartych plików:

package main

import (
    "fmt"
    "os"
    "sync"
)

var maxOpenFiles = 100
var sem = make(chan struct{}, maxOpenFiles)

func openFile(path string) (*os.File, error) {
    sem <- struct{}{} // zarezerwuj slot
    f, err := os.Open(path)
    if err != nil {
        <-sem // zwolnij slot w przypadku błędu
        return nil, err
    }
    return f, nil
}

func closeFile(f *os.File) {
    f.Close()
    <-sem // zwolnij slot
}

func main() {
    var wg sync.WaitGroup
    files := []string{"file1.txt", "file2.txt" /* itd. */}

    for _, path := range files {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            f, err := openFile(p)
            if err != nil {
                fmt.Println("Błąd otwarcia pliku:", err)
                return
            }
            defer closeFile(f)

            // Praca z plikiem
        }(path)
    }

    wg.Wait()
}

Ten sposób pomaga kontrolować liczbę jednocześnie otwartych plików i zapobiega przekroczeniu limitów systemowych.