Belajar melalui contoh: Menggunakan bahasa Go untuk membina sistem teragih

Dalam konteks perkembangan pesat Internet hari ini, sistem yang diedarkan telah menjadi bahagian yang amat diperlukan dalam perusahaan dan organisasi besar. Sebagai bahasa pengaturcaraan yang cekap, berkuasa dan mudah difahami, bahasa Go telah menjadi salah satu bahasa pilihan untuk membangunkan sistem teragih. Dalam artikel ini, kita akan belajar cara menggunakan bahasa Go untuk membangunkan sistem teragih melalui contoh.

Langkah 1: Fahami sistem teragih

Sebelum mempelajari bahasa Go secara mendalam, kita perlu memahami apa itu sistem teragih. Ringkasnya, sistem teragih terdiri daripada berbilang nod komputer bebas yang berkomunikasi melalui rangkaian untuk berkongsi sumber dan data. Oleh itu, sistem teragih biasanya mempunyai ciri-ciri berikut:

1. Nod yang berbeza boleh berjalan dan berkembang secara bebas, dengan itu meningkatkan ketersediaan dan toleransi kesalahan sistem
2. Nod mesti Berkomunikasi melalui rangkaian bermakna penghantaran data adalah isu utama;
3. Oleh kerana nod diedarkan, isu seperti keselamatan dan ketekalan data memerlukan perhatian khusus.

Setelah memahami ciri asas sistem teragih, kini kita boleh mula menggunakan bahasa Go untuk melaksanakan sistem sedemikian.

Langkah 2: Laksanakan sistem teragih mudah

Dalam sistem teragih, salah satu tugas yang paling biasa ialah pengkomputeran selari. Di sini, kami akan melaksanakan algoritma MapReduce yang mudah untuk mengira bilangan kejadian setiap perkataan dalam jumlah data yang besar dan mengeluarkan hasilnya.

Pertama, kita perlu menulis fungsi Peta ringkas yang memecahkan semua perkataan kepada pasangan nilai kunci dan mengira setiap perkataan sebagai 1:

func Mapper(text string) []KeyValue{
    var kvs []KeyValue
    words := strings.Fields(strings.ToLower(text))//分割单词并转换为小写
    for _,word := range words{
        kvs = append(kvs,KeyValue{word,"1"})
    }
    return kvs
}

Kemudian, kita menulis fungsi Kurangkan , mengumpulkan kiraan untuk setiap perkataan:

func Reducer(key string, values []string) string{
    count := 0
    for _,val := range values{
        v, _ := strconv.Atoi(val)
        count += v
    }
    return strconv.Itoa(count)//将count转换为string类型
}

Kini, kami mempunyai peta kami dan mengurangkan fungsi. Langkah seterusnya ialah menulis fungsi utama dalam Go untuk menggunakan peta dan mengurangkan fungsi pada set data yang besar.

func main(){
    tasks := make(chan string, 100)
    results := make(chan []KeyValue)//结果集
    workers := 10//工作goroutine数量
    for i:=0;i<workers;i++{
        go doMapReduce(tasks,results)
    }
    go func(){
        for {
            select {
            case <- time.After(10*time.Second):
                close(tasks)
                fmt.Println("Tasks emptied!")
                return
            default:
                tasks <- GetBigData()//GetBigData用来获取大量的文本数据
            }
        }
    }()
    for range results{
        //输出结果
    }
}
//主函数中的doMapReduce函数
func doMapReduce(tasks <-chan string, results chan<- []KeyValue){
    for task := range tasks{
        //Map阶段
        kvs := Mapper(task)
        //Shuffle阶段
        sort.Sort(ByKey(kvs))//按照key排序
        groups := groupBy(kvs)
        //Reduce阶段
        var res []KeyValue
        for k,v := range groups{
            res = append(res,KeyValue{k,Reducer(k,v)})
        }
        results <- res
    }
}

Seperti yang ditunjukkan di atas, dalam fungsi utama, kami mencipta saluran tugas, saluran hasil dan 10 goroutin. Kami menggunakan fungsi doMapReduce untuk melaksanakan pengiraan MapReduce pada setiap tugas dan menghantar hasil pengiraan ke saluran hasil. Akhir sekali, kami membaca semua hasil daripada saluran hasil dan mengeluarkannya.

Langkah 3: Uji sistem yang diedarkan

Untuk menguji sistem yang diedarkan ini, kami boleh menggunakan algoritma SimHash, yang boleh mencari teks yang serupa dalam jumlah data yang besar dengan cepat. Kita boleh mencincang rentetan dan kemudian menggunakan perbezaan dalam nilai cincang untuk mengukur persamaan antara dua rentetan.

func simhash(text string) uint64{
    //SimHash算法
}
func similarity(s1,s2 uint64) float64{
    //计算两个哈希值之间的相似度
}

Kini, kita boleh menggunakan fungsi simhash untuk mengira nilai cincang setiap teks dan fungsi persamaan untuk mengira persamaan antara setiap teks. Dengan cara ini, kita boleh mencari teks yang serupa dan memprosesnya dengan mudah.

func main(){
    var data []string
    for i:=0;i<20;i++{
        data = append(data,GetBigData())
    }
    var hashes []uint64
    for _,text := range data{
        hashes = append(hashes,simhash(text))
    }
    //查找相似文本
    for i:=0;i<len(hashes)-1;i++{
        for j:=i+1;j<len(hashes);j++{
            if(similarity(hashes[i],hashes[j]) > 0.95){
                fmt.Printf("'%v' and '%v' are similar!
",data[i],data[j])
            }
        }
    }
}

Seperti yang ditunjukkan di atas, mengikut prinsip persamaan, kita boleh mencari data teks yang serupa dan kemudian memprosesnya.

Ringkasan:

Melalui contoh yang disediakan dalam artikel ini, kita boleh menguasai kaedah dan teknik menggunakan bahasa Go dengan mendalam untuk membangunkan sistem teragih. Pembangunan sistem teragih perlu mengambil kira faktor seperti konkurensi, toleransi kesalahan dan skalabiliti pada masa yang sama Sebagai bahasa pengaturcaraan yang berkuasa dan mudah difahami, bahasa Go boleh memudahkan proses ini. Saya percaya artikel ini boleh memberikan anda pengalaman pembelajaran dan inspirasi yang baik, supaya anda boleh menggunakan bahasa Go dengan lebih mahir dalam pembangunan.

Atas ialah kandungan terperinci Belajar melalui contoh: Menggunakan bahasa Go untuk membina sistem teragih. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!