Sistem fail, berbilang benang, pemprosesan isyarat dalam bahasa Go

Dengan kemajuan dan pembangunan teknologi komputer yang berterusan, semakin banyak bahasa pengaturcaraan muncul Antaranya, bahasa Go digemari oleh semakin ramai pembangun dan perusahaan kerana keupayaan serentak yang kuat, mekanisme pengumpulan sampah. dan ciri-ciri lain perhatian dan aplikasi yang meluas. Antaranya, sistem fail, multi-threading dan pemprosesan isyarat adalah beberapa ciri yang lebih penting dalam bahasa Go. Artikel ini akan memperincikan prinsip dan aplikasi ciri ini.

1. Sistem fail

Bahasa Go menyediakan antara muka yang berkaitan dengan operasi fail melalui pakej os. Sebagai contoh, pakej os menyediakan struktur Fail untuk mewakili fail, dan menyediakan kaedah seperti Buka dan Buat untuk membuka dan mencipta fail. Ia juga menyediakan kaedah seperti Tutup, Stat, Baca dan Tulis untuk mengendalikan fail. Kodnya adalah seperti berikut:

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Create("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    file.Write([]byte("hello world
"))
    file.Sync()

    file, err = os.Open("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    data := make([]byte, 100)
    count, err := file.Read(data)
    if err != nil {
        panic(err)
    }
    fmt.Printf("read %d bytes from file: %s", count, data)
}

Dalam kod di atas, kami mencipta dan membuka fail bernama test.txt melalui pakej os, menulis baris rentetan "hello world" padanya, dan kemudian menyimpan cache Data dalam disegerakkan ke fail. Kemudian, kami membuka semula fail, membaca kandungannya dan mencetaknya. Perlu diingatkan bahawa kami menggunakan pernyataan tangguh untuk memastikan fail ditutup pada penghujung fungsi untuk mengelakkan kebocoran sumber.

Selain itu, bahasa Go juga menyediakan pakej laluan dan pakej laluan fail untuk mengendalikan isu yang berkaitan dengan laluan fail. Contohnya, pakej laluan menyediakan kaedah seperti Join, Dir, dan Base untuk mengendalikan rentetan laluan, manakala pakej laluan fail menyediakan kaedah seperti Clean, Join dan Split untuk mengendalikan isu seperti pemisah laluan di bawah sistem pengendalian yang berbeza.

2. Multi-threading

Bahasa Go menyediakan keupayaan pengaturcaraan serentak yang kuat dalam bentuk goroutine dan saluran. Coroutine ialah benang ringan yang boleh dibuat dan dimusnahkan dengan mudah, dan kos penukaran konteksnya sangat kecil, sekali gus menyokong penciptaan dan menjalankan sejumlah besar coroutine. Saluran ialah mekanisme asas untuk komunikasi antara coroutine, membolehkan mereka memindahkan dan berkongsi data tanpa kunci. Kodnya adalah seperti berikut:

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d started job %d
", id, j)
        time.Sleep(time.Second)
        fmt.Printf("worker %d finished job %d
", id, j)
        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 <= 9; j++ {
        jobs <- j
    }
    close(jobs)

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

Dalam kod di atas, kami mentakrifkan pekerja coroutine kerja, yang membaca tugasan daripada saluran kerja, melaksanakan tugasan, dan kemudian menulis keputusan ke saluran hasil. Kami mencipta tiga coroutine kerja melalui gelung dan lulus dalam saluran kerja dan hasil sebagai parameter. Seterusnya, kami meletakkan 9 tugasan ke dalam saluran kerja dan membaca keputusan daripada keputusan apabila tugasan selesai. Perlu diingatkan bahawa kami menggunakan pernyataan tutup untuk menutup saluran kerja untuk memberitahu coroutine pekerja bahawa tiada lagi tugas yang perlu dilakukan.

Selain itu, bahasa Go juga menyediakan mekanisme seperti kunci mutex dan kunci baca-tulis dalam pakej penyegerakan untuk memastikan keselamatan akses kepada sumber yang dikongsi. Sebagai contoh, apabila membaca dan menulis pembolehubah yang dikongsi, kita boleh menggunakan kunci mutex untuk memastikan bahawa hanya satu goroutine boleh mengakses pembolehubah pada masa yang sama.

3. Pemprosesan isyarat

Bahasa Go menyediakan pakej os untuk memproses isyarat (isyarat). Isyarat ialah kaedah komunikasi antara proses dalam sistem UNIX/Linux Ia digunakan untuk memberitahu proses berlakunya peristiwa tertentu, seperti gangguan, penamatan, dsb.

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    fmt.Println("awaiting signal")
    <-sigs
    fmt.Println("exiting")
}

Dalam kod di atas, kami menangkap isyarat SIGINT dan SIGTERM melalui pakej isyarat dan mengikatnya ke saluran sigs melalui fungsi Notify. Kemudian, kita menunggu ketibaan isyarat dengan membaca isyarat dari saluran sigs. Perlu diingat bahawa kami menggunakan pemalar yang ditakrifkan dalam pakej syscall untuk mewakili jenis isyarat Sebagai contoh, SIGINT mewakili isyarat gangguan dan SIGTERM mewakili isyarat penamatan.

Selain itu, kami juga boleh menyesuaikan jenis isyarat dan menggunakan pakej os/isyarat untuk memprosesnya dalam program. Sebagai contoh, kami boleh melaksanakan mekanisme penyegerakan keadaan kongsi yang mudah seperti kunci teragih melalui isyarat tersuai dalam program.

Ringkasnya, sistem fail, pelbagai benang dan pemprosesan isyarat adalah beberapa ciri yang lebih penting dalam bahasa Go. Penggunaan gabungannya membolehkan kami menulis program yang cekap dan mantap. Pada masa yang sama, disebabkan sintaks ringkas dan reka bentuk konkurensi yang baik bagi bahasa Go, ia sesuai digunakan dalam pengkomputeran awan, kontena dan bidang lain, dan merupakan bahasa pengaturcaraan arah aliran masa hadapan.

Atas ialah kandungan terperinci Sistem fail, berbilang benang, pemprosesan isyarat dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!