Load Package

func Avg() (*AvgStat, error)
func AvgWithContext(ctx context.Context) (*AvgStat, error)

func Misc() (*MiscStat, error)
func MiscWithContext(ctx context.Context) (*MiscStat, error)

type AvgStat struct {
    Load1  float64 // 1-minute load average
    Load5  float64 // 5-minute load average
    Load15 float64 // 15-minute load average
}

type MiscStat struct {
    ProcsTotal   int // Total number of processes
    ProcsCreated int // Number of processes created since boot
    ProcsRunning int // Number of running processes
    ProcsBlocked int // Number of blocked processes
    Ctxt         int // Number of context switches since boot
}

package main

import (
    "fmt"
    "github.com/shirou/gopsutil/v4/load"
)

func main() {
    loadAvg, err := load.Avg()
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Load Averages:\n")
    fmt.Printf("  1 min:  %.2f\n", loadAvg.Load1)
    fmt.Printf("  5 min:  %.2f\n", loadAvg.Load5)
    fmt.Printf("  15 min: %.2f\n", loadAvg.Load15)
}

package main

import (
    "fmt"
    "github.com/shirou/gopsutil/v4/cpu"
    "github.com/shirou/gopsutil/v4/load"
)

func main() {
    // Get number of CPU cores
    cpuCount, _ := cpu.Counts(true)
    
    loadAvg, err := load.Avg()
    if err != nil {
        panic(err)
    }
    
    // Calculate utilization percentage
    util1 := (loadAvg.Load1 / float64(cpuCount)) * 100
    util5 := (loadAvg.Load5 / float64(cpuCount)) * 100
    util15 := (loadAvg.Load15 / float64(cpuCount)) * 100
    
    fmt.Printf("CPU Cores: %d\n", cpuCount)
    fmt.Printf("Load Average & Utilization:\n")
    fmt.Printf("  1 min:  %.2f (%.1f%%)\n", loadAvg.Load1, util1)
    fmt.Printf("  5 min:  %.2f (%.1f%%)\n", loadAvg.Load5, util5)
    fmt.Printf("  15 min: %.2f (%.1f%%)\n", loadAvg.Load15, util15)
    
    // Alert if system is overloaded
    if loadAvg.Load1 > float64(cpuCount) {
        fmt.Println("\n⚠️  WARNING: System is overloaded!")
    }
}

package main

import (
    "fmt"
    "github.com/shirou/gopsutil/v4/load"
)

func main() {
    misc, err := load.Misc()
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Process Statistics:\n")
    fmt.Printf("  Total Processes: %d\n", misc.ProcsTotal)
    fmt.Printf("  Running: %d\n", misc.ProcsRunning)
    fmt.Printf("  Blocked: %d\n", misc.ProcsBlocked)
    fmt.Printf("  Created Since Boot: %d\n", misc.ProcsCreated)
    fmt.Printf("  Context Switches: %d\n", misc.Ctxt)
}

package main

import (
    "fmt"
    "time"
    "github.com/shirou/gopsutil/v4/load"
)

func main() {
    for {
        loadAvg, err := load.Avg()
        if err != nil {
            fmt.Println("Error:", err)
            continue
        }
        
        misc, err := load.Misc()
        if err != nil {
            fmt.Println("Error:", err)
            continue
        }
        
        fmt.Printf("\n[%s]\n", time.Now().Format("15:04:05"))
        fmt.Printf("Load: %.2f %.2f %.2f | ", 
            loadAvg.Load1, loadAvg.Load5, loadAvg.Load15)
        fmt.Printf("Procs: %d total, %d running, %d blocked\n",
            misc.ProcsTotal, misc.ProcsRunning, misc.ProcsBlocked)
        
        time.Sleep(5 * time.Second)
    }
}

package main

import (
    "context"
    "fmt"
    "time"
    "github.com/shirou/gopsutil/v4/load"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    loadAvg, err := load.AvgWithContext(ctx)
    if err != nil {
        panic(err)
    }
    
    misc, err := load.MiscWithContext(ctx)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Load: %.2f, Processes: %d\n", 
        loadAvg.Load1, misc.ProcsTotal)
}