go語言調(diào)用系統(tǒng) go調(diào)用系統(tǒng)命令

go語言如何調(diào)用c函數(shù)

直接嵌入c源代碼到go代碼里面

成都創(chuàng)新互聯(lián)公司堅持“要么做到，要么別承諾”的工作理念，服務領(lǐng)域包括：成都網(wǎng)站設(shè)計、做網(wǎng)站、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣等服務，滿足客戶于互聯(lián)網(wǎng)時代的鐵力網(wǎng)站設(shè)計、移動媒體設(shè)計的需求，幫助企業(yè)找到有效的互聯(lián)網(wǎng)解決方案。努力成為您成熟可靠的網(wǎng)絡(luò)建設(shè)合作伙伴！

package main

/*

#include stdio.h

void myhello(int i) {

printf("Hello C: %d\n", i);

}

*/

import "C"

import "fmt"

func main() {

C.myhello(C.int(12))

fmt.Println("Hello Go");

}

需要注意的是C代碼必須放在注釋里面

import "C"語句和前面的C代碼之間不能有空行

運行結(jié)果

$ go build main.go ./main

Hello C: 12

Hello Go

分開c代碼到單獨文件

嵌在一起代碼結(jié)構(gòu)不是很好看，很多人包括我，還是喜歡把兩個分開，放在不同的文件里面，顯得干凈，go源文件里面是go的源代碼，c源文件里面是c的源代碼。

$ ls

hello.c hello.h main.go

$ cat hello.h

void hello(int);

$ cat hello.c

#include stdio.h

void hello(int i) {

printf("Hello C: %d\n", i);

}

$ cat main.go

package main

// #include "hello.h"

import "C"

import "fmt"

func main() {

C.hello(C.int(12))

fmt.Println("Hello Go");

}

編譯運行

$ go build ./main

Hello C: 12

Hello Go

編譯成庫文件

如果c文件比較多，最好還是能夠編譯成一個獨立的庫文件，然后go來調(diào)用庫。

$ find mylib main

mylib

mylib/hello.h

mylib/hello.c

main

main/main.go

編譯庫文件

$ cd mylib

# gcc -fPIC -shared -o libhello.so hello.c

編譯go程序

$ cd main

$ cat main.go

package main

// #cgo CFLAGS: -I../mylib

// #cgo LDFLAGS: -L../mylib -lhello

// #include "hello.h"

import "C"

import "fmt"

func main() {

C.hello(C.int(12))

fmt.Println("Hello Go");

}

$ go build main.go

運行

$ export LD_LIBRARY_PATH=../mylib

$ ./main

Hello C: 12

Hello Go

在我們的例子中，庫文件是編譯成動態(tài)庫的，main程序鏈接的時候也是采用的動態(tài)庫

$ ldd main

linux-vdso.so.1 = (0x00007fffc7968000)

libhello.so = ../mylib/libhello.so (0x00007f513684c000)

libpthread.so.0 = /lib64/libpthread.so.0 (0x00007f5136614000)

libc.so.6 = /lib64/libc.so.6 (0x00007f5136253000)

/lib64/ld-linux-x86-64.so.2 (0x000055d819227000)

理論上講也是可以編譯成整個一靜態(tài)鏈接的可執(zhí)行程序，由于我的機器上缺少靜態(tài)鏈接的系統(tǒng)庫，比如libc.a，所以只能編譯成動態(tài)鏈接。

Go語言——goroutine并發(fā)模型

參考：

Goroutine并發(fā)調(diào)度模型深度解析手擼一個協(xié)程池

Golang 的 goroutine 是如何實現(xiàn)的？

Golang - 調(diào)度剖析【第二部分】

OS線程初始棧為2MB。Go語言中，每個goroutine采用動態(tài)擴容方式，初始2KB，按需增長，最大1G。此外GC會收縮?？臻g。

BTW，增長擴容都是有代價的，需要copy數(shù)據(jù)到新的stack，所以初始2KB可能有些性能問題。

更多關(guān)于stack的內(nèi)容，可以參見大佬的文章。 聊一聊goroutine stack

用戶線程的調(diào)度以及生命周期管理都是用戶層面，Go語言自己實現(xiàn)的，不借助OS系統(tǒng)調(diào)用，減少系統(tǒng)資源消耗。

Go語言采用兩級線程模型，即用戶線程與內(nèi)核線程KSE（kernel scheduling entity）是M:N的。最終goroutine還是會交給OS線程執(zhí)行，但是需要一個中介，提供上下文。這就是G-M-P模型

Go調(diào)度器有兩個不同的運行隊列：

go1.10\src\runtime\runtime2.go

Go調(diào)度器根據(jù)事件進行上下文切換。

調(diào)度的目的就是防止M堵塞，空閑，系統(tǒng)進程切換。

詳見 Golang - 調(diào)度剖析【第二部分】

Linux可以通過epoll實現(xiàn)網(wǎng)絡(luò)調(diào)用，統(tǒng)稱網(wǎng)絡(luò)輪詢器N（Net Poller）。

文件IO操作

上面都是防止M堵塞，任務竊取是防止M空閑

每個M都有一個特殊的G，g0。用于執(zhí)行調(diào)度，gc，棧管理等任務，所以g0的棧稱為調(diào)度棧。g0的棧不會自動增長，不會被gc，來自os線程的棧。

go1.10\src\runtime\proc.go

G沒辦法自己運行，必須通過M運行

M通過通過調(diào)度，執(zhí)行G

從M掛載P的runq中找到G，執(zhí)行G

一學就會，手把手教你用Go語言調(diào)用智能合約

智能合約調(diào)用是實現(xiàn)一個 DApp 的關(guān)鍵，一個完整的 DApp 包括前端、后端、智能合約及區(qū)塊 鏈系統(tǒng)，智能合約的調(diào)用是連接區(qū)塊鏈與前后端的關(guān)鍵。

我們先來了解一下智能合約調(diào)用的基礎(chǔ)原理。智能合約運行在以太坊節(jié)點的 EVM 中。因此要 想調(diào)用合約必須要訪問某個節(jié)點。

以后端程序為例，后端服務若想連接節(jié)點有兩種可能，一種是雙 方在同一主機，此時后端連接節(jié)點可以采用 本地 IPC(Inter-Process Communication，進 程間通信)機制，也可以采用 RPC(Remote Procedure Call，遠程過程調(diào)用)機制;另 一種情況是雙方不在同一臺主機，此時只能采用 RPC 機制進行通信。

提到 RPC， 讀者應該對 Geth 啟動參數(shù)有點印象，Geth 啟動時可以選擇開啟 RPC 服務，對應的 默認服務端口是 8545。。

接著，我們來了解一下智能合約運行的過程。

智能合約的運行過程是后端服務連接某節(jié)點，將 智能合約的調(diào)用(交易)發(fā)送給節(jié)點，節(jié)點在驗證了交易的合法性后進行全網(wǎng)廣播，被礦工打包到 區(qū)塊中代表此交易得到確認，至此交易才算完成。

就像數(shù)據(jù)庫一樣，每個區(qū)塊鏈平臺都會提供主流 開發(fā)語言的 SDK(Software Development Kit，軟件開發(fā)工具包)，由于 Geth 本身就是用 Go 語言 編寫的，因此若想使用 Go 語言連接節(jié)點、發(fā)交易，直接在工程內(nèi)導入 go-ethereum(Geth 源碼) 包就可以了，剩下的問題就是流程和 API 的事情了。

總結(jié)一下，智能合約被調(diào)用的兩個關(guān)鍵點是節(jié)點和 SDK。

由于 IPC 要求后端與節(jié)點必須在同一主機，所以很多時候開發(fā)者都會采用 RPC 模式。除了 RPC，以太坊也為開發(fā)者提供了 json- rpc 接口，本文就不展開討論了。

接下來介紹如何使用 Go 語言，借助 go-ethereum 源碼庫來實現(xiàn)智能合約的調(diào)用。這是有固定 步驟的，我們先來說一下總體步驟，以下面的合約為例。

步驟 01:編譯合約，獲取合約 ABI(Application Binary Interface，應用二進制接口)。 單擊【ABI】按鈕拷貝合約 ABI 信息，將其粘貼到文件 calldemo.abi 中(可使用 Go 語言IDE 創(chuàng)建該文件，文件名可自定義，后綴最好使用 abi)。

最好能將 calldemo.abi 單獨保存在一個目錄下，輸入“l(fā)s”命令只能看到 calldemo.abi 文件，參 考效果如下:

步驟 02:獲得合約地址。注意要將合約部署到 Geth 節(jié)點。因此 Environment 選擇為 Web3 Provider。

在【Environment】選項框中選擇“Web3 Provider”，然后單擊【Deploy】按鈕。

部署后，獲得合約地址為:0xa09209c28AEf59a4653b905792a9a910E78E7407。

步驟 03:利用 abigen 工具(Geth 工具包內(nèi)的可執(zhí)行程序)編譯智能合約為 Go 代碼。abigen 工具的作用是將 abi 文件轉(zhuǎn)換為 Go 代碼，命令如下:

其中各參數(shù)的含義如下。 (1)abi:是指定傳入的 abi 文件。 (2)type:是指定輸出文件中的基本結(jié)構(gòu)類型。 (3)pkg:指定輸出文件 package 名稱。 (4)out:指定輸出文件名。 執(zhí)行后，將在代碼目錄下看到 funcdemo.go 文件，讀者可以打開該文件欣賞一下，注意不要修改它。

步驟 04:創(chuàng)建 main.go，填入如下代碼。 注意代碼中 HexToAddress 函數(shù)內(nèi)要傳入該合約部署后的地址，此地址在步驟 01 中獲得。

步驟 04:設(shè)置 go mod，以便工程自動識別。

前面有所提及，若要使用 Go 語言調(diào)用智能合約，需要下載 go-ethereum 工程，可以使用下面 的指令:

該指令會自動將 go-ethereum 下載到“$GOPATH/src/github.com/ethereum/go-ethereum”，這樣還算 不錯。不過，Go 語言自 1.11 版本后，增加了 module 管理工程的模式。只要設(shè)置好了 go mod，下載 依賴工程的事情就不必關(guān)心了。

接下來設(shè)置 module 生效和 GOPROXY，命令如下:

在項目工程內(nèi)，執(zhí)行初始化，calldemo 可以自定義名稱。

步驟 05:運行代碼。執(zhí)行代碼，將看到下面的效果，以及最終輸出的 2020。

上述輸出信息中，可以看到 Go 語言會自動下載依賴文件，這就是 go mod 的神奇之處?？吹?2020，相信讀者也知道運行結(jié)果是正確的了。

【golang詳解】go語言GMP(GPM)原理和調(diào)度

Goroutine調(diào)度是一個很復雜的機制，下面嘗試用簡單的語言描述一下Goroutine調(diào)度機制，想要對其有更深入的了解可以去研讀一下源碼。

首先介紹一下GMP什么意思：

G ----------- goroutine: 即Go協(xié)程，每個go關(guān)鍵字都會創(chuàng)建一個協(xié)程。

M ---------- thread內(nèi)核級線程，所有的G都要放在M上才能運行。

P ----------- processor處理器，調(diào)度G到M上，其維護了一個隊列，存儲了所有需要它來調(diào)度的G。

Goroutine 調(diào)度器P和 OS 調(diào)度器是通過 M 結(jié)合起來的，每個 M 都代表了 1 個內(nèi)核線程，OS 調(diào)度器負責把內(nèi)核線程分配到 CPU 的核上執(zhí)行

模型圖：

避免頻繁的創(chuàng)建、銷毀線程，而是對線程的復用。

1）work stealing機制

當本線程無可運行的G時，嘗試從其他線程綁定的P偷取G，而不是銷毀線程。

2）hand off機制

當本線程M0因為G0進行系統(tǒng)調(diào)用阻塞時，線程釋放綁定的P，把P轉(zhuǎn)移給其他空閑的線程執(zhí)行。進而某個空閑的M1獲取P，繼續(xù)執(zhí)行P隊列中剩下的G。而M0由于陷入系統(tǒng)調(diào)用而進被阻塞，M1接替M0的工作，只要P不空閑，就可以保證充分利用CPU。M1的來源有可能是M的緩存池，也可能是新建的。當G0系統(tǒng)調(diào)用結(jié)束后，根據(jù)M0是否能獲取到P，將會將G0做不同的處理：

如果有空閑的P，則獲取一個P，繼續(xù)執(zhí)行G0。

如果沒有空閑的P，則將G0放入全局隊列，等待被其他的P調(diào)度。然后M0將進入緩存池睡眠。

如下圖

GOMAXPROCS設(shè)置P的數(shù)量，最多有GOMAXPROCS個線程分布在多個CPU上同時運行

在Go中一個goroutine最多占用CPU 10ms，防止其他goroutine被餓死。

具體可以去看另一篇文章

【Golang詳解】go語言調(diào)度機制 搶占式調(diào)度

當創(chuàng)建一個新的G之后優(yōu)先加入本地隊列，如果本地隊列滿了，會將本地隊列的G移動到全局隊列里面，當M執(zhí)行work stealing從其他P偷不到G時，它可以從全局G隊列獲取G。

協(xié)程經(jīng)歷過程

我們創(chuàng)建一個協(xié)程 go func()經(jīng)歷過程如下圖：

說明：

這里有兩個存儲G的隊列，一個是局部調(diào)度器P的本地隊列、一個是全局G隊列。新創(chuàng)建的G會先保存在P的本地隊列中，如果P的本地隊列已經(jīng)滿了就會保存在全局的隊列中；處理器本地隊列是一個使用數(shù)組構(gòu)成的環(huán)形鏈表，它最多可以存儲 256 個待執(zhí)行任務。

G只能運行在M中，一個M必須持有一個P，M與P是1：1的關(guān)系。M會從P的本地隊列彈出一個可執(zhí)行狀態(tài)的G來執(zhí)行，如果P的本地隊列為空，就會想其他的MP組合偷取一個可執(zhí)行的G來執(zhí)行；

一個M調(diào)度G執(zhí)行的過程是一個循環(huán)機制；會一直從本地隊列或全局隊列中獲取G

上面說到P的個數(shù)默認等于CPU核數(shù)，每個M必須持有一個P才可以執(zhí)行G，一般情況下M的個數(shù)會略大于P的個數(shù)，這多出來的M將會在G產(chǎn)生系統(tǒng)調(diào)用時發(fā)揮作用。類似線程池，Go也提供一個M的池子，需要時從池子中獲取，用完放回池子，不夠用時就再創(chuàng)建一個。

work-stealing調(diào)度算法：當M執(zhí)行完了當前P的本地隊列隊列里的所有G后，P也不會就這么在那躺尸啥都不干，它會先嘗試從全局隊列隊列尋找G來執(zhí)行，如果全局隊列為空，它會隨機挑選另外一個P，從它的隊列里中拿走一半的G到自己的隊列中執(zhí)行。

如果一切正常，調(diào)度器會以上述的那種方式順暢地運行，但這個世界沒這么美好，總有意外發(fā)生，以下分析goroutine在兩種例外情況下的行為。

Go runtime會在下面的goroutine被阻塞的情況下運行另外一個goroutine：

用戶態(tài)阻塞/喚醒

當goroutine因為channel操作或者network I/O而阻塞時（實際上golang已經(jīng)用netpoller實現(xiàn)了goroutine網(wǎng)絡(luò)I/O阻塞不會導致M被阻塞，僅阻塞G，這里僅僅是舉個栗子），對應的G會被放置到某個wait隊列(如channel的waitq)，該G的狀態(tài)由_Gruning變?yōu)開Gwaitting，而M會跳過該G嘗試獲取并執(zhí)行下一個G，如果此時沒有可運行的G供M運行，那么M將解綁P，并進入sleep狀態(tài)；當阻塞的G被另一端的G2喚醒時（比如channel的可讀/寫通知），G被標記為，嘗試加入G2所在P的runnext（runnext是線程下一個需要執(zhí)行的 Goroutine。）， 然后再是P的本地隊列和全局隊列。

系統(tǒng)調(diào)用阻塞

當M執(zhí)行某一個G時候如果發(fā)生了阻塞操作，M會阻塞，如果當前有一些G在執(zhí)行，調(diào)度器會把這個線程M從P中摘除，然后再創(chuàng)建一個新的操作系統(tǒng)的線程(如果有空閑的線程可用就復用空閑線程)來服務于這個P。當M系統(tǒng)調(diào)用結(jié)束時候，這個G會嘗試獲取一個空閑的P執(zhí)行，并放入到這個P的本地隊列。如果獲取不到P，那么這個線程M變成休眠狀態(tài)， 加入到空閑線程中，然后這個G會被放入全局隊列中。

隊列輪轉(zhuǎn)

可見每個P維護著一個包含G的隊列，不考慮G進入系統(tǒng)調(diào)用或IO操作的情況下，P周期性的將G調(diào)度到M中執(zhí)行，執(zhí)行一小段時間，將上下文保存下來，然后將G放到隊列尾部，然后從隊列中重新取出一個G進行調(diào)度。

除了每個P維護的G隊列以外，還有一個全局的隊列，每個P會周期性地查看全局隊列中是否有G待運行并將其調(diào)度到M中執(zhí)行，全局隊列中G的來源，主要有從系統(tǒng)調(diào)用中恢復的G。之所以P會周期性地查看全局隊列，也是為了防止全局隊列中的G被餓死。

除了每個P維護的G隊列以外，還有一個全局的隊列，每個P會周期性地查看全局隊列中是否有G待運行并將其調(diào)度到M中執(zhí)行，全局隊列中G的來源，主要有從系統(tǒng)調(diào)用中恢復的G。之所以P會周期性地查看全局隊列，也是為了防止全局隊列中的G被餓死。

M0

M0是啟動程序后的編號為0的主線程，這個M對應的實例會在全局變量rutime.m0中，不需要在heap上分配，M0負責執(zhí)行初始化操作和啟動第一個G，在之后M0就和其他的M一樣了

G0

G0是每次啟動一個M都會第一個創(chuàng)建的goroutine，G0僅用于負責調(diào)度G，G0不指向任何可執(zhí)行的函數(shù)，每個M都會有一個自己的G0，在調(diào)度或系統(tǒng)調(diào)用時會使用G0的?？臻g，全局變量的G0是M0的G0

一個G由于調(diào)度被中斷，此后如何恢復？

中斷的時候?qū)⒓拇嫫骼锏臈Ｐ畔?，保存到自己的G對象里面。當再次輪到自己執(zhí)行時，將自己保存的棧信息復制到寄存器里面，這樣就接著上次之后運行了。

我這里只是根據(jù)自己的理解進行了簡單的介紹，想要詳細了解有關(guān)GMP的底層原理可以去看Go調(diào)度器 G-P-M 模型的設(shè)計者的文檔或直接看源碼

參考： ()

()

go語言框架有的不支持windows

根據(jù)資料顯示，go語言框架有的不支持windows，是因為與運行的 Windows 版本不兼容。那么需要安裝與windows兼容的版本，即可。

怎么樣使用Go語言中函數(shù)的參數(shù)傳遞與調(diào)用

按值傳遞函數(shù)參數(shù)，是拷貝參數(shù)的實際值到函數(shù)的形式參數(shù)的方法調(diào)用。在這種情況下，參數(shù)在函數(shù)內(nèi)變化對參數(shù)不會有影響。

默認情況下，Go編程語言使用調(diào)用通過值的方法來傳遞參數(shù)。在一般情況下，這意味著，在函數(shù)內(nèi)碼不能改變用來調(diào)用所述函數(shù)的參數(shù)?？紤]函數(shù)swap()的定義如下。

代碼如下:

/* function definition to swap the values */

func swap(int x, int y) int {

var temp int

temp = x /* save the value of x */

x = y /* put y into x */

y = temp /* put temp into y */

return temp;

}

現(xiàn)在，讓我們通過使實際值作為在以下示例調(diào)用函數(shù)swap()：

代碼如下:

package main

import "fmt"

func main() {

/* local variable definition */

var a int = 100

var b int = 200

fmt.Printf("Before swap, value of a : %d\n", a )

fmt.Printf("Before swap, value of b : %d\n", b )

/* calling a function to swap the values */

swap(a, b)

fmt.Printf("After swap, value of a : %d\n", a )

fmt.Printf("After swap, value of b : %d\n", b )

}

func swap(x, y int) int {

var temp int

temp = x /* save the value of x */

x = y /* put y into x */

y = temp /* put temp into y */

return temp;

}

讓我們把上面的代碼放在一個C文件，編譯并執(zhí)行它，它會產(chǎn)生以下結(jié)果：

Before swap, value of a :100

Before swap, value of b :200

After swap, value of a :100

After swap, value of b :200

這表明，參數(shù)值沒有被改變，雖然它們已經(jīng)在函數(shù)內(nèi)部改變。

通過傳遞函數(shù)參數(shù)，即是拷貝參數(shù)的地址到形式參數(shù)的參考方法調(diào)用。在函數(shù)內(nèi)部，地址是訪問調(diào)用中使用的實際參數(shù)。這意味著，對參數(shù)的更改會影響傳遞的參數(shù)。

要通過引用傳遞的值，參數(shù)的指針被傳遞給函數(shù)就像任何其他的值。所以，相應的，需要聲明函數(shù)的參數(shù)為指針類型如下面的函數(shù)swap()，它的交換兩個整型變量的值指向它的參數(shù)。

代碼如下:

/* function definition to swap the values */

func swap(x *int, y *int) {

var temp int

temp = *x /* save the value at address x */

*x = *y /* put y into x */

*y = temp /* put temp into y */

}

現(xiàn)在，讓我們調(diào)用函數(shù)swap()通過引用作為在下面的示例中傳遞數(shù)值：

代碼如下:

package main

import "fmt"

func main() {

/* local variable definition */

var a int = 100

var b int= 200

fmt.Printf("Before swap, value of a : %d\n", a )

fmt.Printf("Before swap, value of b : %d\n", b )

/* calling a function to swap the values.

* a indicates pointer to a ie. address of variable a and

* b indicates pointer to b ie. address of variable b.

*/

swap(a, b)

fmt.Printf("After swap, value of a : %d\n", a )

fmt.Printf("After swap, value of b : %d\n", b )

}

func swap(x *int, y *int) {

var temp int

temp = *x /* save the value at address x */

*x = *y /* put y into x */

*y = temp /* put temp into y */

}

讓我們把上面的代碼放在一個C文件，編譯并執(zhí)行它，它會產(chǎn)生以下結(jié)果：

Before swap, value of a :100

Before swap, value of b :200

After swap, value of a :200

After swap, value of b :100

這表明變化的功能以及不同于通過值調(diào)用的外部體現(xiàn)的改變不能反映函數(shù)之外。

分享文章：go語言調(diào)用系統(tǒng) go調(diào)用系統(tǒng)命令
本文來源：http://muchs.cn/article48/docoiep.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供標簽優(yōu)化、關(guān)鍵詞優(yōu)化、移動網(wǎng)站建設(shè)、面包屑導航、微信公眾號、網(wǎng)站改版

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)