Golang Pro：Goを使用したネットワーキング、マルチスレッド、データ構造、および機械学習

こんにちは住民！



Go言語の基本にすでに精通していますか？それならこの本はあなたのためです。Michalis Tsukalosは、言語の機能を示し、明確で簡単な説明を行い、例を示し、効果的なプログラミングパターンを提案します。Goのニュアンスを学習することで、言語のデータタイプと構造、およびパッケージング、同時実行、ネットワークプログラミング、コンパイラの設計、最適化などを習得できます。各章の終わりにある資料と演習は、新しい知識を強化するのに役立ちます。ユニークな資料は、Goでの機械学習に関する章で、基本的な統計手法から回帰とクラスタリングまでを説明します。分類、ニューラルネットワーク、および異常検出の手法について学習します。適用セクションでは、Go with DockerとKubernetes、Git、WebAssembly、JSONなどの使用方法を学習します。

そして再びGoチャネルについて

selectキーワードを使用すると、第9章で見たよりもはるかに多くのことを行うGoパイプを使用するいくつかのユニークな方法があります。このセクションでは、Goパイプを使用するさまざまな方法について学習します。



チャネルのゼロ値はnilであり、閉じたチャネルにメッセージを送信すると、プログラムはパニックモードになります。ただし、閉じたチャネルからデータを読み取ろうとすると、このチャネルタイプの値はゼロになります。したがって、チャネルを閉じた後は、チャネルにデータを書き込むことはできなくなりますが、読み取ることはできます。



チャネルを閉じるために、データのみを受信するように設計する必要はありません。さらに、チャネル0は常にブロックされます。つまり、チャネル0からの読み取りまたは書き込みを試みると、チャネルがブロックされます。チャネルのこのプロパティは、チャネル変数をnilに設定してselectステートメントのブランチを無効にする場合に非常に役立ちます。



最後に、ゼロチャネルを閉じようとすると、プログラムはパニックを引き起こします。closeNilChannel.goの例を見てみましょう。

package main

func main() {
      var c chan string
      close(c)
}

closeNilChannel.goを実行すると、次の結果が生成されます。

$ go run closeNilChannel.go
panic: close of nil channel
goroutine 1 [running]:
main.main()
       /Users/mtsouk/closeNilChannel.go:5 +0x2a
exit status 2

信号チャネル

シグナリングチャネルは、シグナリングにのみ使用されるチャネルです。簡単に言えば、信号チャネルは、別のプログラムに何かを通知したいときに使用できます。データの転送にシグナリングチャネルを使用する必要はありません。

シグナリングチャネルは、第8章で説明したUNIX信号処理と混同しないでください。これらは完全に異なるものです。

シグナリングチャネルを使用するコードの例については、この章の後半で説明します。

バッファリングされたチャネル

このサブセクションのトピックは、バッファリングされたパイプです。これらは、Goスケジューラーがジョブをすばやくキューに入れてより多くの要求を処理できるようにするチャネルです。さらに、アプリケーションの帯域幅を制限するためのセマフォとして使用できます。



ここに示す方法は次のように機能します。すべての着信要求はチャネルにリダイレクトされ、チャネルが順番に処理します。チャネルが要求の処理を終了すると、チャネルが新しい要求を処理する準備ができているというメッセージを元の呼び出し元に送信します。したがって、チャネルのバッファ容量は、チャネルが保存できる同時要求の数を制限します。



例としてbufChannel.goプログラムコードを使用してこのメ​​ソッドを見ていきます。それを4つの部分に分けましょう。



bufChannel.goコードの最初の部分は次のようになります。

package main

import (
       "fmt"
)

bufChannel.goファイルの2番目の部分には、次のGoコードが含まれています。

func main() {
      numbers := make(chan int, 5)
      counter := 10

ここに示されている数値の定義により、このパイプに最大5つの整数を格納できます。



bufChannel.goの3番目の部分には、次のGoコードが含まれています。

for i := 0; i < counter; i++ {
     select {
     case numbers <- i:
     default:
            fmt.Println("Not enough space for", i)
     }
}

このコードでは、numbersチャネルに10個の数字を入れようとしました。ただし、数値には5つの整数のスペースしかないため、10個の整数すべてを格納することはできません。



bufChannel.goの残りのGoコードは次のようになります。

   for i := 0; i < counter+5; i++ {
        select {
              case num := <-numbers:
                    fmt.Println(num)
              default:
                    fmt.Println("Nothing more to be done!")
              break
        }
   }
}

このGoコードでは、forループとselectステートメントを使用してnumbersチャネルの内容を読み取ろうとしました。数値チャネルで読み取るものがある限り、selectステートメントの最初のブランチが実行されます。数値チャネルが空の場合、デフォルトの分岐が実行されます。



bufChannel.goを実行すると、次の結果が生成されます。

$ go run bufChannel.go
Not enough space for 5
Not enough space for 6
Not enough space for 7
Not enough space for 8
Not enough space for 9
0
1
2
3
4
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!
Nothing more to be done!

ゼロチャンネル

このセクションでは、チャネルゼロについて学習します。これは、常にブロックされる特別な種類のチャネルです。例としてnilChannel.goプログラムを使用して、これらのチャネルを見ていきます。それを4つのコードに分割しましょう。



nilChannel.goの最初の部分は次のようになります。

package main

import (
       "fmt"
       "math/rand"
       "time"
)

nilChannel.goの2番目の部分には、次のGoコードが含まれています。

func add(c chan int) {
      sum := 0
      t := time.NewTimer(time.Second)

      for {
           select {
           case input := <-c:
                 sum = sum + input
           case <-t.C:
                 c = nil
                 fmt.Println(sum)
           }
      }
}

ここでは、例としてadd（）関数を使用して、ゼロチャネルがどのように使用されるかを示します。<-tC演算子は、time.NewTimer（）の呼び出しで指定された時間、タイマーtのCチャネルをブロックします。関数引数であるチャネルcを、タイマーtに属するチャネルtCと混同しないでください。時間が経過すると、タイマーはtCチャネルに値を送信し、tCチャネルは、selectステートメントの対応するブランチの実行を開始します。チャネルcをnilに設定し、sum変数の値を表示します。



3番目のnilChannel.goコードスニペットは次のようになります。

func send(c chan int) {
      for {
           c <- rand.Intn(10)
      }
}

send（）関数の目的は、ランダムな番号を生成し、チャネルが開いている限りそれらをチャネルに送信することです。



nilChannel.goの残りのGoコードは次のようになります。

func main() {
      c := make(chan int)
      go add(c)
      go send(c)
      time.Sleep(3 * time.Second)
}

2つのゴルーチンを実行するのに十分な時間を確保するには、time.Sleep（）関数が必要です。



nilChannel.goを実行すると、次の結果が生成されます。

$ go run nilChannel.go
13167523
$ go run nilChannel.go
12988362

add（）のselectステートメントの最初のブランチが実行される回数は固定されていないため、nilChannel.goを複数回実行すると異なる結果が生成されます。

チャネルチャネル

チャネルチャネルは、通常の変数タイプの代わりに他のチャネルと連携する特別な種類のチャネル変数です。ただし、チャネルのチャネルのデータタイプを宣言する必要があります。チャネルのチャネルを定義するには、次のステートメントに示すように、chanキーワードを2回続けて使用します。

c1 := make(chan chan int)

この章で紹介する他のタイプのチャネルは、チャネルチャネルよりも人気があり便利です。

chSquare.goファイルにあるサンプルコードを使用して、チャネルチャネルの使用について説明します。それを4つの部分に分けましょう。



chSquare.goの最初の部分は次のようになります。

package main

import (
       "fmt"
       "os"
       "strconv"
       "time"
)

var times int

chSquare.goの2番目の部分には、次のGoコードが含まれています。

func f1(cc chan chan int, f chan bool) {
      c := make(chan int)
      cc <- c
      defer close(c)

      sum := 0
      select {
      case x := <-c:
            for i := 0; i <= x; i++ {
                 sum = sum + i
            }
            c <- sum
      case <-f:
            return
      }
}

intタイプの通常のチャネルを宣言したら、それをチャネルチャネル変数に渡します。次に、selectステートメントを使用して、通常のintチャネルからデータを読み取るか、信号チャネルfを使用して関数を終了する機会を取得します。



チャネルcから1つの値を読み取った後、0から読み取ったばかりの整数値までのすべての整数の合計を計算するforループを実行します。次に、計算された値をintチャネルcに送信します。これで完了です。



chSquare.goの3番目の部分には、次のGoコードが含まれています。

func main() {
      arguments := os.Args
      if len(arguments) != 2 {
          fmt.Println("Need just one integer argument!")
          return
      }
      times, err := strconv.Atoi(arguments[1])
      if err != nil {
           fmt.Println(err)
           return
      }

      cc := make(chan chan int)

このコードスニペットの最後の行で、ccという名前のチャネル変数を宣言します。すべてがそれに依存しているので、この変数はこのプログラムのスターです。 cc変数はf1（）に渡され、次のforループで使用されます。



chSquare.goGoコードの残りの部分は次のようになります。

   for i := 1; i < times+1; i++ {
        f := make(chan bool)
        go f1(cc, f)
        ch := <-cc
        ch <- i
        for sum := range ch {
             fmt.Print("Sum(", i, ")=", sum)
        }
        fmt.Println()
        time.Sleep(time.Second)
        close(f)
    }
}

チャネルfは、すべての作業が完了したときのゴルーチンの終了の信号チャネルです。 ch：= <-cc命令を使用すると、チャネル変数から通常のチャネルを取得して、ch <-i演算子を使用してそこにint値を渡すことができます。その後、forループを使用してパイプからデータを読み取ります。 f1（）関数は1つの値を返すようにプログラムされていますが、複数の値を読み取ることもできます。各i値は、独自のゴルーチンによって提供されることに注意してください。



信号チャネルタイプは、前のコードで使用されたboolや、次のセクションで信号チャネルに使用されるstruct {}など、何でもかまいません。タイプstruct {}のシグナリングチャネルの主な利点は、そのようなチャネルにデータを送信できないことです。これにより、エラーの発生が防止されます。



chSquare.goを実行すると、次のような結果が得られます。

$ go run chSquare.go 4
Sum(1)=1
Sum(2)=3
Sum(3)=6
Sum(4)=10
$ go run chSquare.go 7
Sum(1)=1
Sum(2)=3
Sum(3)=6
Sum(4)=10
Sum(5)=15
Sum(6)=21
Sum(7)=28

ゴルーチンの実行順序の選択

ゴルーチンの実行順序については、何も想定する必要はありません。ただし、この順序を制御する必要がある場合があります。このサブセクションでは、シグナリングチャネルを使用してこれを行う方法を学習します。

「通常の関数で同じことを行う方がはるかに簡単なのに、なぜゴルーチンを作成してから、指定された順序で実行するのですか？」と質問するかもしれません。答えは簡単です。ゴルーチンは同時に実行して他のゴルーチンが完了するのを待つことができますが、関数は順番に実行されるためできません。

このサブセクションでは、defineOrder.goというGoプログラムについて説明します。それを5つの部分に分けましょう。defineOrder.goの最初の部分は次のようになります。

package main

import (
       "fmt"
       "time"
)

func A(a, b chan struct{}) {
      <-a
      fmt.Println("A()!")
      time.Sleep(time.Second)
      close(b)
}

関数A（）は、パラメーターaに格納されているチャネルによってロックされています。このチャネルがmain（）でロック解除されるとすぐに、A（）機能が機能し始めます。最後に、チャネルbを閉じて、別の関数（この場合はB（））のブロックを解除します。



defineOrder.goの2番目の部分には、次のGoコードが含まれています。

func B(a, b chan struct{}) {
      <-a
      fmt.Println("B()!")
      close(b)
}

関数B（）のロジックはA（）のロジックと同じです。この機能は、チャネルaが閉じられるまでブロックされます。次に、その役割を果たし、チャネルbを閉じます。チャネルaおよびbは関数パラメーター名を参照することに注意してください。



defineOrder.goの3番目のコードは次のようになります。

func C(a chan struct{}) {
      <-a
      fmt.Println("C()!")
}

C（）関数はブロックされ、チャネルaが閉じるのを待ってから開始します。



defineOrder.goの4番目の部分には、次のコードが含まれています。

func main() {
      x := make(chan struct{})
      y := make(chan struct{})
      z := make(chan struct{})

これらの3つのチャネルは、3つの機能のパラメーターになります。



defineOrder.goの最後のスニペットには、次のGoコードが含まれています。

     go C(z)
     go A(x, y)
     go C(z)
     go B(y, z)
     go C(z)

     close(x)
     time.Sleep(3 * time.Second)
}

ここで、プログラムは必要なすべての機能を実行してから、xチャネルを閉じ、3秒間スリープします。



defineOrder.goを実行すると、C（）関数が複数回呼び出されても、目的の結果が得られます。

$ go run defineOrder.go
A()!
B()!
C()!
C()!
C()!

C（）はチャネルを閉じないため、ゴルーチンとしてC（）を複数回呼び出しても問題は発生しません。ただし、A（）またはB（）を複数回呼び出すと、次のようなエラーメッセージが表示される可能性があります。

$ go run defineOrder.go
A()!
A()!
B()!
C()!
C()!
C()!
panic: close of closed channel
goroutine 7 [running]:
main.A(0xc420072060, 0xc4200720c0)
       /Users/mtsouk/Desktop/defineOrder.go:12 +0x9d
created by main.main
       /Users/mtsouk/Desktop/defineOrder.go:33 +0xfa
exit status 2

ご覧のとおり、ここではA（）関数が2回呼び出されました。ただし、A（）がチャネルを閉じると、そのゴルーチンの1つがチャネルがすでに閉じられていることを検出し、そのチャネルを再び閉じようとするとパニック状態になります。B（）関数を複数回呼び出そうとすると、同様のパニック状態になります。

ゴルーチンを使わない方法

このセクションでは、ゴルーチンを使用して自然数を並べ替える素朴な方法を学習します。これから説明するプログラムは、sillySort.goと呼ばれます。それを2つの部分に分けましょう。sillySort.goの最初の部分は次のようになります。

package main

import (
       "fmt"
       "os"
       "strconv"
       "sync"
       "time"
)

func main() {
      arguments := os.Args

      if len(arguments) == 1 {
          fmt.Println(os.Args[0], "n1, n2, [n]")
          return
      }

      var wg sync.WaitGroup
      for _, arg := range arguments[1:] {
           n, err := strconv.Atoi(arg)
           if err != nil || n < 0 {
                fmt.Print(". ")
                continue
           }

sillySort.goの2番目の部分には、次のGoコードが含まれています。

           wg.Add(1)
           go func(n int) {
                defer wg.Done()
                time.Sleep(time.Duration(n) * time.Second)
                fmt.Print(n, " ")
           }(n)
      }

      wg.Wait()
      fmt.Println()
}

並べ替えは、time.Sleep（）関数を呼び出すことによって実行されます-自然数が大きいほど、fmt.Print（）演算子が実行されるまでに時間がかかります！



sillySort.goを実行すると、次のような結果が生成されます。

$ go run sillySort.go a -1 1 2 3 5 0 100 20 60
. . 0 1 2 3 5 20 60 100
$ go run sillySort.go a -1 1 2 3 5 0 100 -1 a 20 hello 60
. . . . . 0 1 2 3 5 20 60 100
$ go run sillySort.go 0 0 10 2 30 3 4 30
0 0 2 3 4 10 30 30

著者について

Mihalis Tsoukalosは、UNIX管理者、プログラマー、データベース管理者、および数学者です。技術的な本や記事を書くのが好きで、何か新しいことを学びます。この本に加えて、Michalisは、Go Systems Programmingと、Sys Admin、MacTech、Linux User and Developer、Usenix、login：、Linux Format、LinuxJournalなどの多くの雑誌に250を超える技術記事を書いています。Michalisの研究対象は、データベース、視覚化、統計、および機械学習です。

科学編集者について

Mat Ryerは、6歳からコンピュータープログラムを作成しています。最初はZX SpectrumのBASICで、次に父親と一緒にAmigaBASICとAmosのCommodoreAmigaで作成しました。彼は、Amiga Formatマガジンからコードを手動でコピーし、変数またはGOTOステートメント参照の値を変更して何が起こったのかを確認するために多くの時間を費やしました。同じ探求心とプログラミングへの執着により、18歳のマットは英国のマンスフィールドにある地元の組織で働き、そこでウェブサイトやその他のオンラインサービスの構築を始めました。



ロンドンだけでなく世界中のさまざまな分野でさまざまなテクノロジーを数年間使用した後、マットは、Googleで最初に使用されたGoと呼ばれる新しいシステムプログラミング言語に注意を向けました。 Goは非常に関連性の高い最先端の技術的問題を解決していたため、Matは、Goがまだベータ版であったときに問題解決にこの言語を使い始め、それ以来プログラムを続けています。 Matはさまざまなオープンソースプロジェクトに取り組み、Testify、Moq、Silk and Is、MacOS開発者ツールキットBitBarなどのいくつかのGoパッケージを作成しました。



2018年以来、MatはMachine Boxの共同創設者ですが、それでも会議に参加し、Goについてブログに書き込み、Goコミュニティの積極的なメンバーです。



»本の詳細については、発行元のWebサイトを参照してください

»目次

» 住民向けの抜粋



クーポンの25％割引-Golang



紙版の本の支払い時に、電子書籍が電子メールに送信されます。