Rangka kerja Golang dan rangka kerja Elixir: perspektif unik tentang pengaturcaraan serentak

Golang's Goroutine dan Elixir's Erlang VM menyediakan model pengaturcaraan serentak yang unik. Golang menggunakan benang selari yang ringan (goroutines) untuk menjadualkan tugas dengan cekap dalam satu proses, dan Elixir adalah berdasarkan mesin maya Erlang (BEAM) untuk menyatakan keselarasan melalui mekanisme proses. Dalam kes praktikal, Goroutine atau Erlang VM boleh digunakan untuk melaksanakan tugas merangkak secara selari untuk meningkatkan kecekapan.

Rangka Kerja Golang dan Rangka Kerja Elixir: Perspektif unik tentang pengaturcaraan serentak

Dalam pembangunan perisian moden, pengaturcaraan serentak telah menjadi teknologi penting. Golang dan Elixir ialah dua bahasa pengaturcaraan popular yang menawarkan model pengaturcaraan serentak yang unik Dalam tutorial ini, kami akan meneroka model ini dan menunjukkannya dengan contoh praktikal.

Golang’s Goroutine

Golang menyediakan benang selari ringan yang dipanggil goroutine yang membolehkan pelaksanaan tugas serentak tanpa menyekat fungsi yang memanggilnya. Goroutine menggunakan mekanisme coroutine untuk menjadualkan berbilang operasi serentak dengan cekap dalam satu proses.

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    // 创建一个 goroutine
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("goroutine:", i)
        }
    }()

    // 主线程继续执行
    for i := 0; i < 10; i++ {
        fmt.Println("main:", i)
    }

    // 确保 goroutine 完成后再退出
    time.Sleep(1 * time.Second)

    // 输出
    // goroutine: 0
    // main: 0
    // goroutine: 1
    // main: 1
    // ...
    // goroutine: 9
    // main: 9
}

Elixir's Erlang VM

Elixir adalah berdasarkan Mesin Maya Erlang (BEAM), persekitaran masa jalan yang sangat serentak dan tahan terhadap kerosakan. BEAM melaksanakan Erlang, Elixir, dan bahasa berasaskan BEAM yang lain dan menyediakan mekanisme yang dipanggil proses untuk menyatakan konkurensi.

defmodule MyModule do
  def main do
    # 创建一个进程并向其发送消息
    spawn(fn ->
      receive do
        {_, msg} ->
          IO.println("进程收到消息: #{msg}")
      end
    end)

    # 主进程继续执行
    for i <- 1..10 do
      send(self(), {self(), "消息 #{i}"})
    end
  end
end

MyModule.main

Kes praktikal: Merangkak selari

Menggunakan Golang's Goroutine atau Elixir's Erlang VM, kita boleh melaksanakan tugas merangkak secara selari. Berikut ialah contoh yang dilaksanakan menggunakan Golang:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "runtime"
    "sync"
    "time"
)

func main() {
    // 创建一个同步锁来维护结果
    var lock sync.Mutex
    var wg sync.WaitGroup

    // 创建一个通道来存储结果
    results := make(chan string)

    // 爬取 URL 列表
    urls := []string{"www.google.com", "www.amazon.com", "www.facebook.com"}
    startTime := time.Now()

    for _, url := range urls {
        // 创建一个 goroutine 来爬取每个 URL
        wg.Add(1)

        go func(url string) {
            defer wg.Done()

            // 发送 HTTP 请求
            resp, err := http.Get(url)
            if err != nil {
                results <- fmt.Sprintf("爬取失败: %s", err)
                return
            }

            // 读取并打印响应内容
            contents, err := ioutil.ReadAll(resp.Body)
            resp.Body.Close()
            if err != nil {
                results <- fmt.Sprintf("读取内容失败: %s", err)
                return
            }

            // 使用锁来安全地存储结果
            lock.Lock()
            defer lock.Unlock()
            results <- fmt.Sprintf("爬取成功: %s\n内容:\n%s", url, contents)
        }(url)
    }

    // 等待所有 goroutine 完成
    wg.Wait()
    close(results)

    // 打印结果
    for result := range results {
        fmt.Println(result)
    }

    fmt.Printf("爬取完成，用时：%v\n", time.Since(startTime))
}

Kesimpulan

Golang's Goroutine dan Elixir's Erlang VM menyediakan model pengaturcaraan serentak yang unik dan berkuasa. Dengan menggunakan goroutine dan proses, kami boleh melaksanakan tugas selari dengan cekap dan membina aplikasi berprestasi tinggi.

Atas ialah kandungan terperinci Rangka kerja Golang dan rangka kerja Elixir: perspektif unik tentang pengaturcaraan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!