Examples: Concurrency

package main

import (
    "fmt"
    "time"
    "github.com/go-co-op/gocron/v2"
)

func main() {
    s, _ := gocron.NewScheduler()
    defer s.Shutdown()

    j, _ := s.NewJob(
        gocron.DurationJob(30*time.Second),
        gocron.NewTask(func() {
            fmt.Println("Starting long task...")
            time.Sleep(2 * time.Minute) // Takes longer than interval
            fmt.Println("Long task complete")
        }),
        gocron.WithName("long-task"),
        gocron.WithSingletonMode(gocron.LimitModeReschedule),
    )

    s.Start()
    // Runs at: 0s, 120s, 240s (skips 30s, 60s, 90s, 150s, 180s, 210s)
    select {}
}

func main() {
    s, _ := gocron.NewScheduler()
    defer s.Shutdown()

    j, _ := s.NewJob(
        gocron.DurationJob(30*time.Second),
        gocron.NewTask(func() {
            fmt.Println("Processing queue item...")
            time.Sleep(time.Minute)
            fmt.Println("Queue item processed")
        }),
        gocron.WithName("queue-processor"),
        gocron.WithSingletonMode(gocron.LimitModeWait),
    )

    s.Start()
    // Queues runs at 30s, 60s, 90s; executes sequentially
    select {}
}

func main() {
    s, _ := gocron.NewScheduler(
        gocron.WithLimitConcurrentJobs(3, gocron.LimitModeReschedule),
    )
    defer s.Shutdown()

    // Create 10 jobs
    for i := 0; i < 10; i++ {
        jobNum := i
        s.NewJob(
            gocron.DurationJob(time.Second),
            gocron.NewTask(func() {
                fmt.Printf("Job %d starting\n", jobNum)
                time.Sleep(5 * time.Second)
                fmt.Printf("Job %d complete\n", jobNum)
            }),
            gocron.WithName(fmt.Sprintf("job-%d", i)),
        )
    }

    s.Start()
    // Only 3 jobs run concurrently at any time
    select {}
}

func main() {
    s, _ := gocron.NewScheduler()
    defer s.Shutdown()

    j, _ := s.NewJob(
        gocron.DurationJob(5*time.Minute),
        gocron.NewTask(func() {
            fmt.Println("Starting API call...")
            time.Sleep(2 * time.Minute) // Variable duration
            fmt.Println("API call complete")
        }),
        gocron.WithName("api-call"),
        gocron.WithIntervalFromCompletion(), // 5min rest after completion
    )

    s.Start()
    // Runs at: 0min, 7min (2min work + 5min rest), 14min, etc.
    select {}
}

func main() {
    s, _ := gocron.NewScheduler(
        gocron.WithLimitConcurrentJobs(5, gocron.LimitModeReschedule),
    )
    defer s.Shutdown()

    // Job 1: Rate-limited API calls
    s.NewJob(
        gocron.DurationJob(5*time.Second),
        gocron.NewTask(func() {
            callExternalAPI()
        }),
        gocron.WithName("api-caller"),
        gocron.WithIntervalFromCompletion(),
        gocron.WithSingletonMode(gocron.LimitModeReschedule),
    )

    // Job 2: Sequential processing
    s.NewJob(
        gocron.DurationJob(time.Minute),
        gocron.NewTask(func() {
            processQueueItem()
        }),
        gocron.WithName("queue-processor"),
        gocron.WithSingletonMode(gocron.LimitModeWait),
    )

    // Job 3: Health check (can run concurrently)
    s.NewJob(
        gocron.DurationJob(30*time.Second),
        gocron.NewTask(func() {
            healthCheck()
        }),
        gocron.WithName("health-check"),
    )

    s.Start()
    select {}
}

func callExternalAPI() {
    fmt.Println("Calling API...")
}

func processQueueItem() {
    fmt.Println("Processing queue...")
}

func healthCheck() {
    fmt.Println("Health check...")
}