func main() {
	writer := csv.NewWriter(os.Stdout)
	writer.Write([]string{"abc","efg", "zyx"})
	writer.Write([]string{"1","2", "3"})
	writer.Write([]string{"A","B", "C"})
	writer.Flush()
}

	gzipWriter := gzip.NewWriter(os.Stdout)
	defer gzipWriter.Flush()

func (enc *Encoder) Encode(v interface{}) error {

http localhost:80
HTTP/1.1 200 OK
Content-Encoding: gzip
Content-Length: 41
Date: Thu, 21 Jan 2021 14:33:09 GMT

{
    "Hello": "World"
}

echo "{\"Hello\": \"World\"}"  | jq | tee teefile | gzip 

	w.Header().Set("Content-Encoding", "gzip")

	source := map[string]string{
		"Hello": "World",
	}

	gzipWriter := gzip.NewWriter(w)

	multiWriter := io.MultiWriter(gzipWriter, os.Stdout)

	encoder := json.NewEncoder(multiWriter)
	encoder.SetIndent("", "    ")
	encoder.Encode(source)

	gzipWriter.Flush()

	if wt, ok := src.(WriterTo); ok {
		return wt.WriteTo(dst)
	}
	// Similarly, if the writer has a ReadFrom method, use it to do the copy.
	if rt, ok := dst.(ReaderFrom); ok {
		return rt.ReadFrom(src)
	}

No need to allocate an extra buffer.
CopyBuffer is identical to Copy except that it stages through the provided buffer (if one is required) rather than allocating a temporary one. If buf is nil, one is allocated; otherwise if it has zero length, CopyBuffer panics.

If either src implements WriterTo or dst implements ReaderFrom, buf will not be used to perform the copy.

余分なバッファを割り当てる必要はありません。
CopyBuffer は、一時的なバッファを割り当てるのではなく、(必要な場合には) 提供されたバッファを段階的に使用することを除いては Copy と同じです。buf が nil ならば 1 つが確保され、そうでなければ長さが 0 ならば CopyBuffer はパニックに陥ります。

src が WriterTo を実装しているか，dst が ReaderFrom を実装している場合，buf はコピーを実行するためには使用されません．

	if e := file.pfd.Close(); e != nil {
		if e == poll.ErrFileClosing {
			e = ErrClosed
		}
		err = &PathError{"close", file.name, e}
	}

package main

import "fmt"

type Wallet struct {
	Balance int
}

func (w Wallet) Deposit(i int) {
	w.Balance += i

	fmt.Println(w)
}

func main() {
	wallet := Wallet{}

	wallet.Deposit(10)

	fmt.Println(wallet.Balance == 10) // false
}

package main

import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
)

func main() {
	var b bytes.Buffer
	var rc io.ReadCloser

	//rc = b // コンパイルエラー！

	b2 := ioutil.NopCloser(&b)

	rc = b2

	fmt.Println(rc)
}

func NopCloser(r io.Reader) io.ReadCloser {
	return nopCloser{r}
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)

	readWriter := bufio.NewReadWriter(reader, writer)
	
	fmt.Println(readWriter)
}

// ここでの *Reader は bufio.go の Readerという構造体！ io.Reader という インタフェースじゃないよ！
// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
	return &ReadWriter{r, w}
}

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := os.Stdin
	writer := os.Stdout

	readWriter := bufio.NewReadWriter(reader, writer)

	fmt.Println(readWriter)
}

package main

import (
	"io"
	"os"
)

func main() {
	from, err := os.Open("go.mod")

	if err != nil {
		panic(err)
	}
	defer from.Close()

	to, err := os.Create("go.mod.txt")
	if err != nil {
		panic(err)
	}
	defer to.Close()

	io.Copy(to, from)
}

	// Header maps header keys to values. If the response had multiple
	// headers with the same key, they may be concatenated, with comma
	// delimiters.  (RFC 7230, section 3.2.2 requires that multiple headers
	// be semantically equivalent to a comma-delimited sequence.) When
	// Header values are duplicated by other fields in this struct (e.g.,
	// ContentLength, TransferEncoding, Trailer), the field values are
	// authoritative.
	//
	// Keys in the map are canonicalized (see CanonicalHeaderKey).
	Header Header

conn.Write([]byte("GET / HTTP/1.0\r\nHost: ascii.jp\r\n\r\n")) 
res, err := http.ReadResponse(bufio.NewReader(conn), nil)
// ヘッダーを表示してみる
fmt.Println(res.Header)
// ボディーを表示してみる。最後にはClose()すること 
defer res.Body.Close()

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var buf1 bytes.Buffer
	fmt.Println(buf1)

	buf2 := bytes.NewBuffer([]byte{229,136,157,230,156,159,230,150,135,229,173,151,229,136,151})
	//buf2 := bytes.NewBuffer([]byte{0x10, 0x20, 0x30})

	fmt.Printf("buf2.String()=%v\n", buf2.String())
	fmt.Printf("buf2.Bytes()=%v\n", buf2.Bytes())
	fmt.Printf("buf2.Len()=%v\n", buf2.Len())

	p2 := make([]byte, 16)
	_, _ = buf2.Read(p2)
	fmt.Println(p2)
	fmt.Println(string(p2))

	// bytes.NewBufferString
	buf3 := bytes.NewBufferString("初期文字列")
	fmt.Printf("buf3.String()=%v\n", buf3.String())
	fmt.Printf("buf3=%v\n", buf3)
	p3 := make([]byte, 16)
	buf3.Read(p3)

	fmt.Printf("p3=%v\n", p3)
	fmt.Printf("string(p3)=%v\n", string(p3))

}

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	// 1バイトずつ読み込んでみるコード
	sReader := strings.NewReader("hello")

	for {
		b, err := sReader.ReadByte()

		if err == io.EOF {
			break
		}
		fmt.Println(b, string(b))
	}

}

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
	// HTTPレスポンスが格納されたテキストから HTTP/1.1 だけほしいときみたいな
	// $ curl -I example.com > response.txt
	file, err := os.Open("response.txt")
	if err != nil {
		panic(err)
	}

	lReader := io.LimitReader(file, 8)
	p := make([]byte, 8)

	_, _ = lReader.Read(p)

	fmt.Println(string(p))
}

package main

import (
	"fmt"
	"io"
	"os"
	"strings"
)

func main() {
	reader := strings.NewReader("Example of io.SectionReader\n")
	sectionReader := io.NewSectionReader(reader, -123, 7)
	w, err := io.Copy(os.Stdout, sectionReader)

	fmt.Println(w, err) // 0 strings.Reader.ReadAt: negative offset


}

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

func main() {
	// 16ビットのビッグエンディアンのデータ(10進数で、4097)
	data := []byte{0x10, 0x01}
	var i int16

	// ビッグエンディアンとして読む込み
	binary.Read(bytes.NewReader(data), binary.BigEndian, &i)
	fmt.Printf("data: %d 0x=%x 0b=%b\n", i, i, i)

	// リトルエンディアンとして読み込む
	binary.Read(bytes.NewReader(data), binary.LittleEndian, &i)
	fmt.Printf("data:  %d 0x=%x 0b=%b\n", i, i, i)

}

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

func main() {
	// エンディアンによる結果の違い(16進数表記でみるとパターンめっちゃわかる)
	data := []byte{0x12, 0x34, 0x56, 0x78}
	var i int32

	// ビッグエンディアンとして読む込み
	binary.Read(bytes.NewReader(data), binary.BigEndian, &i)
	fmt.Printf("ビッグエンディアン: 0x=%x\n", i) // 0x=12345678

	// リトルエンディアンとして読み込む
	binary.Read(bytes.NewReader(data), binary.LittleEndian, &i)
	fmt.Printf("リトルエンディアン: 0x=%x\n", i) // 0x=78563412

}

package main

import "fmt"

func main() {
	// byte型アレコレ
	// コンパイルエラー
	// []byte の 1要素は 8bit == 1Byte の領域になっている ← ってか、byte型って言ってるやん！
	// だから、 []byte{0x100} は アウト！ 16進数の3桁ってことは、12bit必要で、8bitでは無理なのじゃ！
	// data1 := []byte{0x100} //  constant 256 overflows byte
	// data2 := []byte{0x101} //  constant 257 overflows byte

	// 頭に0がいっぱいつくのはセーフ！
	data3 := []byte{0xff}
	fmt.Println(data3) // [255]
	data4 := []byte{0x0ff}
	fmt.Println(data4) // [255]
	data5 := []byte{0x000000000000000000000000000000000ff}
	fmt.Println(data5) // [255]

}

// byte型 は uint8 のエイリアスだった！
// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
// type byte = uint8

package main

import "fmt"

func main() {
	// 実験
	var b byte
	var i uint8
	b = i // 代入できる！

	fmt.Println(b == i)
}

chunks = append(chunks,
			io.NewSectionReader(file, offset, int64(length)+12))

chunks = append(chunks,
                // この方が、4バイト（長さ）+ 4バイト（種類）+ 長さ + 4バイト （CRC）というのを表現しやすい
		io.NewSectionReader(file, offset, 4+4+int64(length)+4))

package main

import (
	"encoding/binary"
	"fmt"
	"io"
	"os"
)

func dumpChunk(chunk io.Reader) {
	var length int32 // 32にしているのはナゼなのかを考えてね
	binary.Read(chunk, binary.BigEndian, &length)
	buffer := make([]byte, 4)
	_, _ = chunk.Read(buffer)
	fmt.Printf("chunk '%v' (%d bytes)\n", string(buffer), length)
}

func readChunk(file *os.File) []io.Reader {
	var chunks []io.Reader

	// 最初の8倍とはスキップする(PNGシグニチャ)
	_, _ = file.Seek(8, 0)
	var offset int64 = 8

	for {
		// なぜ、int じゃなくて int32 なの？
		// 32 → 8bit x 4 == 4Bytes
		// あるチャンクの「長さ」の情報がほしいわけです。
		// で、「長さ」情報は、「4バイト」で管理されています。
		// なので、lengthも4バイト(==32bit)である必要がある！
		var length int32

		err := binary.Read(file, binary.BigEndian, &length)
		if err == io.EOF {
			break
		}

		chunks = append(chunks,
			io.NewSectionReader(file, offset, 4+4+int64(length)+4))

		// 次のチャンクの先頭に移動
		// 現在位置は長さを読み終わった箇所なので
		// チャンク名(4バイト) + データ長さ + CRC(4バイト)先に移動
		offset, _ = file.Seek(int64(4+length+4), 1)
	}
	return chunks
}

func main() {
	file, err := os.Open("20210201/Lenna.png")

	if err != nil {
		panic(err)
	}
	defer file.Close()

	chunks := readChunk(file)

	for _, chunk := range chunks {
		dumpChunk(chunk)
	}

}

chunk 'IHDR' (13 bytes)
chunk 'text' (19 bytes)
ASCII PROGRAMMING++
chunk 'sRGB' (1 bytes)
chunk 'IDAT' (473761 bytes)
chunk 'IEND' (0 bytes)

var csvSource = `13101,"100","1000003","ﾄｳｷｮｳﾄ","ﾁﾖﾀﾞｸ","ﾋﾄﾂﾊﾞｼ(1ﾁｮｳﾒ)","東京都","千代田区","一ツ橋（１丁目）",1,0,1,0,0,0
13101,"101","1010003","ﾄｳｷｮｳﾄ","ﾁﾖﾀﾞｸ","ﾋﾄﾂﾊﾞｼ(2ﾁｮｳﾒ)","東京都","千代田区","一ツ橋（２丁目）",1,0,1,0,0,0
13101,"100","1000012","ﾄｳｷｮｳﾄ","ﾁﾖﾀﾞｸ","ﾋﾋﾞﾔｺｳｴﾝ","東京都","千代田区","日比谷公園",0,0,0,0,0,0
13101,"102","1020093","ﾄｳｷｮｳﾄ","ﾁﾖﾀﾞｸ","ﾋﾗｶﾜﾁｮｳ","東京都","千代田区","平河町",0,0,1,0,0,0
13101,"102","1020071","ﾄｳｷｮｳﾄ","ﾁﾖﾀﾞｸ","ﾌｼﾞﾐ","東京都","千代田区","富士見",0,0,1,0,0,0`

func main () {
	reader := strings.NewReader(csvSource)
	csvReader := csv.NewReader(reader)
	for {
		line, err := csvReader.Read()
		if err == io.EOF {
			break
		}
		fmt.Println(line[2], line[6:8])
	}
}

func main() {
	file, err := os.Create("test.json")
	if err != nil {
		panic(err)
	}

	writer := gzip.NewWriter(file)
	encoder := json.NewEncoder(writer)
	encoder.SetIndent("", "    ")
	encoder.Encode(map[string]string{
		"example": "encoding/json",
		"hello": "world",
	})

}

package main

import (
	"encoding/binary"
	"fmt"
	"io"
	"os"
)

func main() {
	file, err := os.Open("20210201/Lenna.png")

	if err != nil {
		panic(err)
	}
	defer file.Close()

	// PNGのシグニチャー分の8バイトは読み飛ばす
	_, _ = file.Seek(8, 0)

	// 最初のチャンクの長さ情報を取得しに行く
	b := make([]byte, 4)
	_, _ = io.ReadFull(file, b)

	fmt.Println(b) // [0 0 0 13] ← 末尾4バイト

	// 単なる int へのキャストはできない！
	//fmt.Println(int(b)) // コンパイルエラー！

	// バイト列をどの順序で読むか(エンディアン)によって結果が大きく違う
	fmt.Println(binary.BigEndian.Uint32(b))    //        13 ← [0 0 0 13]
	fmt.Println(binary.LittleEndian.Uint32(b)) // 218103808 ← [13 0 0 0]

}

func handler(w http.ResponseWriter, r *http.Request){
	w.Header().Set("Content-Type", "application/zip")
	w.Header().Set("Content-Disposition","attachment; filename=ascii_sample.zip")

	io.WriteString(w, "http.aaaaaaa sample")
	//zipWriter := zip.NewWriter(w)
	//defer zipWriter.Close()
	//
	//writer, err := zipWriter.Create("newFile.txt")
	//
	//if err != nil {
	//	panic(err)
	//}
	//
	//fmt.Fprint(writer, "writer http zip")
}

package main

import (
	"archive/zip"
	"bytes"
	"fmt"
	"io"
	"log"
	"os"
	"strings"
)

// Q3.3
// zip ファイルの書き込み

func main() {
	file, err := os.Create("q33_1.zip")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	zipWriter := zip.NewWriter(file)
	defer zipWriter.Close()

	w1, err := zipWriter.Create("w1.txt")
	if err != nil {
		log.Fatal(err)
	}

	// せっかくなのでいろんな書き方で
	io.Copy(w1, bytes.NewBufferString("w1 ですよ！"))
	io.Copy(w1, strings.NewReader("hello from strings NewReader"))

	if _, err := w1.Write([]byte("w1 ですよ")); err != nil {
		log.Fatal(err)
	}
	if _, err := fmt.Fprint(w1, "w1 を Fprintで"); err != nil {
		log.Fatal(err)
	}

	// 2つめのテキストファイル
	w2, err := zipWriter.Create("w2.txt")
	if err != nil {
		log.Fatal(err)
	}

	io.Copy(w2, bytes.NewBufferString("w2 なんですよ"))
	io.Copy(w2, strings.NewReader("hello from strings NewReader"))
	if _, err := w2.Write([]byte("w2 なんですよ")); err != nil {
		log.Fatal(err)
	}
	if _, err := fmt.Fprint(w2, "w2 を Fprintで"); err != nil {
		log.Fatal(err)
	}

}

package main

import (
	"fmt"
	"io"
	"os"
	"strings"
)

// Q3.5：CopyN
// io.Copy() と本章で紹介した構造体のどれかを使って、
// 3.2.2「コピーの補助関 数」で紹介した
// io.CopyN(dest io.Writer, src io.Reader, length int) を 実装してみてください。

func main() {
	r1 := strings.NewReader("hello world")
	_, _ = io.CopyN(os.Stdout, r1, 5)
	fmt.Println("\n======")

	r2 := strings.NewReader("hello world")
	_ = myCopyN(os.Stdout, r2, 5)
	fmt.Println("\n======")

	r3 := strings.NewReader("hello world")
	_ = myCopyN2(os.Stdout, r3, 5)
}

// io.LimitReader 使うほうが楽だ...!!!
func myCopyN2(w io.Writer, r io.Reader, n int64) error {
	lr := io.LimitReader(r, n)

	if _, err := io.Copy(w, lr); err != nil {
		return err
	}

	return nil
}

// io.Copy() を使わないバージョン
func myCopyN(w io.Writer, r io.Reader, n int64) error {
	buf := make([]byte, n)

	if _, err := io.ReadFull(r, buf); err != nil {
		return err
	}

	fmt.Fprint(w, string(buf))

	return nil
}

package main

import (
	"io"
	"os"
	"strings"
)

var (
	computer    = strings.NewReader("COMPUTER")
	system      = strings.NewReader("SYSTEM")
	programming = strings.NewReader("PROGRAMMING")
)

func main() {
	var stream io.Reader
	// A progrAmming
	// S System
	// C Computer
	// I programmIng
	// I programmIng

	A := io.NewSectionReader(programming, 5, 1)
	S := io.LimitReader(system, 1)
	C := io.LimitReader(computer, 1)
	I1 := io.NewSectionReader(programming, 8, 1)
	I2 := io.NewSectionReader(programming, 8, 1)

	stream = io.MultiReader(A, S, C, I1, I2)

	io.Copy(os.Stdout, stream)
}

package main

func main() {
	// バッファがたりねぇ！
	tasks := make(chan string, 1)

	// データを送信(チャネルにデータを送る)
	tasks <- "cmake .."
	// fmt.Println(<-tasks) // バッファの空きを作ればpanicにならない

	// fatal error: all goroutines are asleep - deadlock!
	tasks <- "cmake . --build Debug"

}

package main

import "fmt"

func main() {
	tasks := make(chan string, 1)

	fmt.Println(<-tasks) // これもpanic
}

package main

import (
	"fmt"
	"time"
)

func main() {
	// バッファなしチャネル
	// バッファなしだけど、goroutineだから、panicにならない
	tasks := make(chan string)

	go func() {
		// データを送信(チャネルにデータを送る)
		fmt.Println("データ送信開始！")

		tasks <- "cmake .."
		fmt.Println("データ送信1個オワタよ！")

		tasks <- "cmake . --build Debug"
		fmt.Println("データ送信完了！！")
	}()

	go func() {
		// データを受信(チャネルからデータを受け取る)
		task1 := <-tasks
		fmt.Println("受信その1 OK",task1)
		task2, ok := <-tasks
		fmt.Println("受信その2 OK",task2, ok)

	}()

	time.Sleep(3 * time.Second)

}

package main

import "fmt"

func main() {
	// closeするとどうなるの？
	// 『プログラミング言語Go』 p.260
	// そのチャネルに値がこれ以上は送信されないことを示すフラグを設定します
	// その後に送信を試みるとpanicになります。
	// 閉じられたチャネルに対する受信操作は、値がなくなるまで送信された値を生成します。
	// 値がなくなったあとの受信奏者すぐに完了し、チャネルの要素型のゼロ値を生成します。
	ch := make(chan string, 10)

	ch <- "一富士"
	ch <- "弐鷹"

	close(ch)

	v, ok := <-ch
	fmt.Printf("v: %v ok: %v\n", v, ok)

	v, ok = <-ch
	fmt.Printf("v: %v ok: %v\n", v, ok)

	// すべて取り尽くしたので、falseになる
	// close()しておかないと、panic fatal error: all goroutines are asleep - deadlock!
	v, ok = <-ch
	fmt.Printf("v: %v ok: %v\n", v, ok) // v:  ok: false

	v, ok = <-ch
	fmt.Printf("v: %v ok: %v\n", v, ok) // v:  ok: false

	v, ok = <-ch
	fmt.Printf("v: %v ok: %v\n", v, ok) // v:  ok: false

}

package main

func main() {
	ch := make(chan string, 10)

	ch <- "一富士"
	ch <- "弐鷹"

	close(ch) // チャネルを閉じたぞ！！！！

	ch <- "三なすび" // panic: send on closed channel
}

package main

import (
	"fmt"
	"time"
)

func main() {
	naturals := make(chan int)
	squares := make(chan int)

	// Counter
	go func() {
		for x := 0; ; x++ {
			naturals <- x
			time.Sleep(300 * time.Millisecond)
		}
	}()

	// Squarer
	go func() {
		for {
			x := <-naturals
			squares <- x * x
		}
	}()

	// Printer(メインゴールーチン)
	for {
		fmt.Println(<-squares)
	}
}

package main

import (
	"fmt"
	"time"
)

func main() {
	// closeすると、複数のgoroutineに一気に終了を通知できる(嬉しい例)
	done := make(chan bool)

	go func() {
		<-done
		fmt.Println("一富士")
	}()
	go func() {
		<-done
		fmt.Println("にたか")
	}()
	go func() {
		<-done
		fmt.Println("三なすび")
	}()

	go func() {
		fmt.Println("すごく重要な処理")
		time.Sleep(1000 * time.Millisecond)
		fmt.Println("みんな！ 終了したぞ！")
		close(done)
	}()

	time.Sleep(3 * time.Second)
}

package main

import (
	"fmt"
	"time"
)

func main() {
	// closeしたほうが通知には便利を知るための、だめな例
	done := make(chan bool)

	go func() {
		<-done
		fmt.Println("一富士")
	}()
	go func() {
		<-done
		fmt.Println("にたか")
	}()
	go func() {
		<-done
		fmt.Println("三なすび")
	}()

	go func() {
		fmt.Println("すごく重要な処理")
		time.Sleep(1000 * time.Millisecond)
		fmt.Println("みんな！ 終了したぞ！")

		done<-true // 1つのgoroutineの早いもの勝ちになる
		done<-true // 2つのgoroutineの早いもの勝ちになる
	}()

	time.Sleep(3 * time.Second)
}

from time import sleep


def gen():
    i = 0

    while True:
        i += 1
        yield i

        if i == 10:
            break


def main():
    for num in gen():
        sleep(0.1)
        print(num)


if __name__ == '__main__':
    main()

package main

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

func main() {
	reader := make(chan int)
	exit := make(chan bool)

	go func() {
		// データ読み込み処理
		//time.Sleep(2 * time.Second)
		for i := 1; i <= 20; i++ {
			reader <- i
			time.Sleep(300 * time.Millisecond)
		}
	}()

	go func() {
		// 終了のお知らせ
		time.Sleep(2 * time.Second)
		exit <- true
	}()

	for {
		select {
		case data := <-reader:
			fmt.Println("読み込んだデータは", data)
		case <-exit:
			fmt.Println("本日は閉店しました")
			os.Exit(0)
		}
	}
}

package main

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

func main() {
	reader := make(chan int)

	go func() {
		// データ読み込み処理
		time.Sleep(3 * time.Second)
		reader <- 123
	}()

	for {
		select {
		case data := <-reader:
			fmt.Println("読み込んだデータは", data)
			os.Exit(0)
		default:
			time.Sleep(500 * time.Millisecond)
			fmt.Println("確認中です")
		}
	}
}

find / -inum {inode}

[root@9f2a352ba4ea linux]# cat | cat

[root@9f2a352ba4ea fd]# ps auxw
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.0  11816  2916 pts/0    Ss   13:46   0:00 bash
root        20  0.0  0.0  11840  3032 pts/1    Ss   13:48   0:00 /bin/bash
root        44  0.0  0.0   4396   604 pts/0    S+   13:50   0:00 cat
root        45  0.0  0.0   4396   660 pts/0    S+   13:50   0:00 cat
root       209  0.0  0.1  51744  3356 pts/1    R+   14:27   0:00 ps auxw

[root@9f2a352ba4ea /]# ll /proc/{44,45}/fd
/proc/44/fd:
total 0
lrwx------ 1 root root 64 Feb 15 13:51 0 -> /dev/pts/0
l-wx------ 1 root root 64 Feb 15 13:51 1 -> pipe:[277640]
lrwx------ 1 root root 64 Feb 15 13:51 2 -> /dev/pts/0

/proc/45/fd:
total 0
lr-x------ 1 root root 64 Feb 15 13:51 0 -> pipe:[277640]
lrwx------ 1 root root 64 Feb 15 13:51 1 -> /dev/pts/0
lrwx------ 1 root root 64 Feb 15 13:51 2 -> /dev/pts/0

[root@9f2a352ba4ea /]# find ./ -inum 277640

[root@9f2a352ba4ea /]# find / -inum 278674 -ls
278674    0 l-wx------   1 root     root           64 Feb 15 13:51 /proc/44/fd/1 -> pipe:[277640]
[root@9f2a352ba4ea /]#

package main

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

// シグナルの送り方
// 1. SIGTERM: `kill {ProcessID}`
// 2. SIGINT: Control+C
// 参考: https://qiita.com/Kernel_OGSun/items/e96cef5487e25517a576#%E6%A8%99%E6%BA%96%E3%82%B7%E3%82%B0%E3%83%8A%E3%83%AB%E3%81%A8%E5%AF%BE%E5%BF%9C%E3%81%99%E3%82%8B%E6%A8%99%E6%BA%96%E5%8B%95%E4%BD%9C
func main() {
	fmt.Printf("Process ID: %v\n", os.Getpid())

	signals := make(chan os.Signal, 1)
	signal.Notify(signals)

	s := <-signals
	fmt.Printf("\nGot signal: %s \n", s)
}

package main

// https://golang.org/ref/spec#Select_statements
func main() {
	var ch chan int
	
	select {
	case ch <- 123: // これ該当するときはいつなの？ コンパイルエラーではないし...
		println("sent!!")
	default:
		println("なにもないよ")
	}

}

// 渋川本
func Open(path string, mode int, perm uint32) (fd int, err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil { return }
	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	use(unsafe.Pointer(_p0))
	fd = int(r0)

	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

// Go 1.16
func Pathconf(path string, name int) (val int, err error) {
	var _p0 *byte
	_p0, err = BytePtrFromString(path)
	if err != nil {
		return
	}
	r0, _, e1 := syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	val = int(r0)
	if e1 != 0 {
		err = errnoErr(e1)
	}
	return
}

# time cat cat.c > /dev/null

real	0m0.008s
user	0m0.000s
sys	0m0.003s

docker run -it --rm -w /home/linux --mount type=bind,source=$(pwd),target=/home/linux linuxpg bash

yum install -y sysstat

for i in $(seq 1 10000000 ) ; do : ; done

sar -P ALL 1

15:13:26        CPU     %user     %nice   %system   %iowait    %steal     %idle
15:13:27        all      9.63      0.00      4.81      0.00      0.00     85.56
15:13:27          0     13.98      0.00      4.30      0.00      0.00     81.72
15:13:27          1      5.32      0.00      5.32      0.00      0.00     89.36

15:13:27        CPU     %user     %nice   %system   %iowait    %steal     %idle
15:13:28        all     12.70      0.00     11.64      0.00      0.00     75.66
15:13:28          0     12.90      0.00     12.90      0.00      0.00     74.19
15:13:28          1     11.83      0.00      9.68      0.00      0.00     78.49

15:13:28        CPU     %user     %nice   %system   %iowait    %steal     %idle
15:13:29        all     28.24      0.00     36.47      0.00      0.00     35.29
15:13:29          0     18.39      0.00     21.84      0.00      0.00     59.77
15:13:29          1     38.10      0.00     52.38      0.00      0.00      9.52

15:13:29        CPU     %user     %nice   %system   %iowait    %steal     %idle
15:13:30        all     48.00      0.00     14.86      0.00      0.00     37.14
15:13:30          0     39.33      0.00     13.48      0.00      0.00     47.19
15:13:30          1     55.68      0.00     17.05      0.00      0.00     27.27

func Open(path string, mode int, perm uint32) (fd int, err error) {
    return openat(_AT_FDCWD, path, mode|O_LARGEFILE, perm)
}

// mksysnum_darwin.pl /usr/include/sys/syscall.h
// Code generated by the command above; DO NOT EDIT.

// +build amd64,darwin

package syscall

const (
	SYS_SYSCALL                        = 0
	SYS_EXIT                           = 1
	SYS_FORK                           = 2
	SYS_READ                           = 3
	SYS_WRITE                          = 4
	SYS_OPEN                           = 5
// 略

Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode),uintptr(perm))

package main

func main() {
	var u uint32

	u = -1 // constant -1 overflows uint32 代入できないじゃなくてoverflowなのか！

	print(u)
}

func cgocall(fn, arg unsafe.Pointer) int32 {
	if !iscgo && GOOS != "solaris" && GOOS != "illumos" && GOOS != "windows" {
		throw("cgocall unavailable")
	}

__visible noinstr void do_syscall_64(unsigned long nr, struct pt_regs *regs)
{
	nr = syscall_enter_from_user_mode(regs, nr); // ← これじゃね？

	instrumentation_begin();
	if (likely(nr < NR_syscalls)) {
		nr = array_index_nospec(nr, NR_syscalls);
		regs->ax = sys_call_table[nr](regs);
#ifdef CONFIG_X86_X32_ABI
	} else if (likely((nr & __X32_SYSCALL_BIT) &&
			  (nr & ~__X32_SYSCALL_BIT) < X32_NR_syscalls)) {
		nr = array_index_nospec(nr & ~__X32_SYSCALL_BIT,
					X32_NR_syscalls);
		regs->ax = x32_sys_call_table[nr](regs);
#endif
	}
	instrumentation_end();
	syscall_exit_to_user_mode(regs); // これじゃね？
}

package main

import (
	"os"
)

func main() {
	f, _ := os.Create("sample.txt")
	defer f.Close()

	f.Write([]byte("hello world"))
}

openat(AT_FDCWD, "sample.txt", O_RDWR|O_CREAT|O_TRUNC|O_CLOEXEC, 0666) = 3
epoll_create1(EPOLL_CLOEXEC)            = 4
pipe2([5, 6], O_NONBLOCK|O_CLOEXEC)     = 0
epoll_ctl(4, EPOLL_CTL_ADD, 5, {EPOLLIN, {u32=5325136, u64=5325136}}) = 0
epoll_ctl(4, EPOLL_CTL_ADD, 3, {EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET, {u32=3865341576, u64=140371986509448}}) = -1 EPERM (Operation not permitted)
epoll_ctl(4, EPOLL_CTL_DEL, 3, 0xc0000a2da4) = -1 EPERM (Operation not permitted)
write(3, "hello world", 11)             = 11
close(3)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++```

#!/bin/usr/python3
f = open("sample.txt", mode="w")

f.write("hello world")

f.close()

openat(AT_FDCWD, "sample.txt", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0666) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
ioctl(3, TCGETS, 0x7ffe71d37ab0)        = -1 ENOTTY (Inappropriate ioctl for device)
lseek(3, 0, SEEK_CUR)                   = 0
ioctl(3, TCGETS, 0x7ffe71d379f0)        = -1 ENOTTY (Inappropriate ioctl for device)
stat("/go/src", {st_mode=S_IFDIR|0777, st_size=4096, ...}) = 0
stat("/go/src", {st_mode=S_IFDIR|0777, st_size=4096, ...}) = 0
stat("/go/src", {st_mode=S_IFDIR|0777, st_size=4096, ...}) = 0
openat(AT_FDCWD, "/go/src", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 4
fstat(4, {st_mode=S_IFDIR|0777, st_size=4096, ...}) = 0
getdents64(4, /* 8 entries */, 32768)   = 232
getdents64(4, /* 0 entries */, 32768)   = 0
close(4)                                = 0
stat("/usr/lib/python3.7", {st_mode=S_IFDIR|0755, st_size=12288, ...}) = 0
stat("/usr/lib/python3.7/_bootlocale.py", {st_mode=S_IFREG|0644, st_size=1801, ...}) = 0
stat("/usr/lib/python3.7/_bootlocale.py", {st_mode=S_IFREG|0644, st_size=1801, ...}) = 0
openat(AT_FDCWD, "/usr/lib/python3.7/__pycache__/_bootlocale.cpython-37.pyc", O_RDONLY|O_CLOEXEC) = 4
fstat(4, {st_mode=S_IFREG|0644, st_size=1231, ...}) = 0
lseek(4, 0, SEEK_CUR)                   = 0
fstat(4, {st_mode=S_IFREG|0644, st_size=1231, ...}) = 0
read(4, "B\r\r\n\0\0\0\0\260-\34_\t\7\0\0\343\0\0\0\0\0\0\0\0\0\0\0\0\10\0\0"..., 1232) = 1231
read(4, "", 1)                          = 0
close(4)                                = 0
lseek(3, 0, SEEK_CUR)                   = 0
write(3, "hello world from Python", 23) = 23
close(3)                                = 0

File.open("sample.txt", mode = "w"){|f|
  f.write("hello from Ruby")
}

openat(AT_FDCWD, "sample.txt", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0666) = 7
ioctl(7, TCGETS, 0x7ffc76ccbbf0)        = -1 ENOTTY (Inappropriate ioctl for device)
write(7, "hello from Ruby", 15)         = 15
close(7)                                = 0