Penjadualan kerja dan peruntukan berbilang tugas dalam bahasa Go

Bahasa Go ialah bahasa pengaturcaraan yang cekap, ringkas dan serentak Sokongan konkurensi yang berkuasa dan urutan yang ringan ialah ciri utama bahasa Go. Bahasa Go juga menyediakan mekanisme yang sepadan untuk melaksanakan penjadualan masa dan peruntukan berbilang tugas Artikel ini akan memperkenalkan penjadualan kerja dan peruntukan berbilang tugas dalam bahasa Go.

1. Penjadualan Kerja

Penjadualan kerja dalam bahasa Go boleh dilaksanakan dengan bantuan pakej masa Fungsi NewTicker, NewTimer dan Sleep yang disediakan oleh pakej ini boleh membantu kami melengkapkan penjadualan kerja yang berbeza keperluan. Mengambil NewTicker sebagai contoh, prototaip fungsinya adalah seperti berikut:

func NewTicker(d Tempoh) *Ticker

Parameter d mewakili selang masa setiap ticker, dan Ticker mengembalikan saluran dalam yang boleh dibaca Dapatkan acara masa. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTicker(time.Millisecond * 500)
    defer t.Stop()
    for i := 0; i < 10; i++ {
        <-t.C
        fmt.Println("tick")
    }
}

Dalam kod di atas, kami menggunakan NewTicker untuk mencipta penanda yang mencetuskan setiap 500 milisaat dan menggunakan gelung for untuk menerima mesej saluran dan mencetak "tanda".

Sudah tentu, kita juga boleh menggunakan NewTimer untuk mencipta jadual kerja sekali sahaja Prototaip fungsi adalah seperti berikut:

func NewTimer(d Duration) *Timer

Parameter d Mewakili tempoh menunggu, Pemasa mengembalikan saluran di mana peristiwa masa boleh dibaca. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("starting...")
    t := time.NewTimer(time.Second)
    <-t.C
    fmt.Println("done")
}

Dalam kod di atas, kami menggunakan NewTimer untuk mencipta pemasa dengan tempoh 1 saat dan menunggu pemasa tamat dalam saluran. Coretan kod ini akan menunggu selama 1 saat dan kemudian mencetak "selesai".

2. Peruntukan berbilang tugas

Bahasa Go sememangnya menyokong pengaturcaraan serentak, jadi kami boleh melaksanakan peruntukan berbilang tugas dengan mudah. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d processing job %d
", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        <-results
    }
}

Dalam kod di atas, kami melaksanakan pengalokasi tugas mudah, mencipta 3 coroutine pekerja dan menetapkan tugasan kepada saluran. Setiap coroutine pekerja membaca tugasan daripada saluran, melaksanakan tugasan dan mengembalikan keputusan kepada saluran hasil. Fungsi utama menunggu semua keputusan dikembalikan.

Ringkasan

Sokongan serentak yang cekap bagi bahasa Go memberikan kami penjadualan kerja yang mudah dan pelaksanaan peruntukan berbilang tugas. Melalui fungsi NewTicker, NewTimer dan Sleep bagi pakej masa, kami boleh melaksanakan penjadualan masa dengan mudah. Melalui coroutine dan saluran, kami boleh melaksanakan pengedaran berbilang tugas dengan mudah. Ciri-ciri ini membolehkan kami melaksanakan pengaturcaraan serentak dan pengagihan tugas dengan lebih pantas apabila menulis kod setiap hari, dan meningkatkan kecekapan dan prestasi kod berjalan.

Atas ialah kandungan terperinci Penjadualan kerja dan peruntukan berbilang tugas dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!