いくつかの一般的な同時実行モデルの枠組みをgolang

説明リンク
メインパッケージ
 
のインポート（
	「FMT」
	「数学/ RAND」
	、「OS」
	「ランタイム」
	「同期」
	「同期/アトミック」
	「時間」
）
 
シナリオのstruct {入力
	名文字列
	説明[]文字列
	として[]ストリング
	runExample FUNC（）
} 
VARをシナリオ＆= {S1 
	名： "S1"、
	説明：[] {文字列
		"単純なタスクを同時に実行"、
	}、
	例：[] {文字列
		"は、そのようなインターフェースリア同時要求"を、
	}、
	runExample：RunScenario1、
} 
 
＆シナリオS2 = {VAR 
	名： "S2"、
	説明：[] {文字列
		「所定時間高い並行性モデル」
	}、 
	例：[] {文字列 
		、「所定の期間内に、サービス無限ループを防ぐために、高い同時リクエストのバックエンドサービスを持続」
	}、
	runExample：RunScenario2、
} 
 
VAR S3 =＆シナリオ{ 
	名：「S3」、
	説明：[]の文字列{ 
		「モデル同時タスク大きなデータ量、プールワーカーをゴルーチンに基づいて」
	}、
	例：[] {文字列
		、「そのような顧客を与えるための技術サポートなど、いくつかのTB / GBのファイルを削除する」
	}、
	runExample：RunScenario3、
} 
 
VAR S4 =＆シナリオ{ 
	名： "S4"、
	説明：[]の文字列{ 
		、 "タスク（ゴルーチン+ SELECT +チャネル）の非同期実行結果を待つ" 
	}、
	例：[]ストリング{ 
		"" 
	}、
	runExample：RunScenario4、
} 
 
VAR＆シナリオS5 = { 
	名："S5"、 
	説明：[]の文字列{
		「フィードバック結果（ティッカー）のタイミング」は、 
	} 
	}、
	例：[] {文字列
		"は、リアルタイムの指標を与えるために、アップロードするインターフェイスの試験性能として：スループット、IOPS、成功率"、
	}、
	runExample：RunScenario5、
} 
 
VARシナリオ[] *シナリオ
 
INIT FUNC（）{ 
	シナリオ=追記（シナリオS1）
	シナリオ=アペンド（シナリオ、S2）
	のシナリオ=アペンド（シナリオ、S3）
	シナリオ=アペンド（シナリオ、S4）
	シナリオ=アペンド（シナリオ、S5）
} 
 
//並行処理と共通同期シナリオ
主FUNC（ ）{ 
	。lenは（os.Args）IF 1 == { 
		fmt.Println（ "シーンを選んでください==>"）
		=レンジシナリオ{：_、SC用
			fmt.Printf（ "シーン：％sを、" SC。名前）
			printDescription（sc.Description）
		} 
		戻り
	_ため、引数：=レンジos.Args [1] { 
（iは整数）のVaRのdoSomethingの= funcを文字列{
		SC：= matchScenario（引数）
		！ならSC =ゼロ{ 
			printDescription（sc.Description）
			printExamples（sc.Examples）
			sc.RunExample（）
		} 
	} 
} 
 
printDescription（STR []の文字列）FUNC { 
	fmt.Printf（「场景描述： ％S \ n」は、STR）
} 
 
FUNC printExamples（STR []の文字列）{ 
	fmt.Printf（ "场景举例：％Sの\ n"、STR）
} 
 
FUNC matchScenario（名前の文字列）*シナリオ{ 
	_、SC用：=範囲シナリオ{ 
		ならsc.Name ==名前{ 
			戻りSC 
		} 
	} 
	リターンゼロ
} 
	fmt.Printf（ "ゴルーチン％のD物事.... \ n"は、 私）
 
	time.Sleep（time.Millisecond * time.Duration（10））
	fmt.Sprintfを返す（ "ゴルーチン％dの"、I）
} 
 
VARのtakeSomthing = FUNC（RES列）列{ 
	time.Sleep（time.Millisecond * time.Duration （10））
	TMP = fmt.Sprintf（ "％sから生じる取る.... \ n"は、RES）
	fmt.Println（TMP）
	戻りTMP 
} 
 
//场景1：简单并发任务
 
FUNC RunScenario1（）{ 
	カウント：= 10 
	のvarのWG sync.WaitGroup 
 
	私のために：= 0; I <数えます。私は{++ 
		wg.Add（1）
		移動FUNC（インデックスINT）{ 
			延期wg.Done（）
			doSomethingの（インデックス）
		}（I）
	} 
 
	wg.Wait（）
} 
 
按时间来持续并发：//场景2 
 
FUNC RunScenario2を（） {
	タイムアウト= time.Now（）（time.Second * time.Duration（10））を追加します。 
	N = runtime.NumCPU（）
 
	waitForAll：=作る（チャン構造体は、{}）が
	行わ：=作る（チャン構造体{}）
	concurrentCount：（=作るちゃんのstruct { }、n）の
 
	iについて：= 0; 私は、n <; 私は{++ 
		<concurrentCountを-のstruct {} {} 
	} 
 
	FUNC行く（）{ 
		time.Now用（）（タイムアウト）する前に、{。
			<-done 
			concurrentCount < -のstruct {} {} 
		} 
 
		waitForAll < -のstruct {} {} 
	}（ ）
 
	（）FUNC行く{ 
		ため{ 
			<-concurrentCount 
			行くFUNC（）{ 
				doSomethingの（rand.Intn（n））を
				行う< -のstruct {} {} 
			}（）
		} 
	}（）
 
	<-waitForAll 
}
  
//场景3：以ワーカープール方式并发做事/发送请求
 
FUNC RunScenario3（）{ 
	numOfConcurrency：= runtime.NumCPU（）
	taskTool：= 10の
	ジョブ：=作る（ちゃんint型、taskTool）
	結果：=作る（ちゃんint型、taskTool）
	VaRのWG同期。 WaitGroup 
 
	// workExample 
	workExampleFunc：=のFUNC（ID int型、ジョブ<ちゃんintは、<ちゃん結果- INT、WG * sync.WaitGroup）{ 
		）（wg.Doneを保留
		ジョブの：=範囲ジョブ{ 
			RES =ジョブ* 2 
			fmt.Printf（ "ワーカー％dの結果は％d \ nを生成する、ことを行う"、ID、RES）
			time.Sleep（time.Millisecond * time.Duration（100））
			結果< - RES 
		} 
	} 
 
	iについて：= 0; 私はnumOfConcurrencyを<; 私は{++ 
		wg.Add（1）
		workExampleFunc（I、ジョブ、結果、およびWG）を行きます
	}
	totalTasks：= 100 
		ために{
  
	wg.Add（1）
	FUNCを行く（）{ 
		wg.Done（）を延期
		iについて：= 0; 私はtotalTasksを<; I ++ { 
			N：= <-results 
			fmt.Printf（ "結果％Dの\ nを得た"、N）
		} 
		近い（結果）
	}（）
 
	iについて：= 0; 私はtotalTasksを<; I ++ { 
		ジョブ< - I 
	} 
	（ジョブ）近い
	wg.Wait（）
} 
 
4场景//：等待异步任务执行结果（ゴルーチン+は+チャネルを選択）
 
RunScenario4（）{FUNC 
	STH：=（チャン列）する
	結果：=をする（チャン列）
	行くFUNC（）{ 
		ID：= rand.Intn（100）
		のために{ 
			STH < -のdoSomething（ID）
		} 
	}（）
	FUNC行く（）{ 
			結果< - takeSomthing（< - STH）
		} 
	}（）
  
	SELECT { 
	ケースC：= <-result：
		fmt.Printf（ "％Sガットの結果"、C）
	ケース<-time.After（time.Duration（30 * time.Second） ）：
		fmt.Errorf（）は、 "指定された時間が生じない" 
	} 
} 
 
VARのdoUploadMock = FUNC（）{BOOLの
	）time.sleep（time.Millisecond time.Duration *（100）
	= rand.Intn（100）：N- 
	N-IF> {50 
		trueに戻り
	}他{ 
		falseに戻り
	} 
} 
 
//シナリオ5：フィードバック結果（ティッカー）タイミング
インタフェースの//試験性能リアルタイム指標を与えるために、アップロードする：スループット、成功率
 
RunScenario5 FUNC（） { 
	totalSize：のInt64 =（0）
	totalCountプロパティ：= Int64型（0）
	totalErr：= Int64型（0）
 
	concurrencyCount：= runtime.NumCPU（）
	（ちゃんのstruct {}）=作る：停止 
	= int64モード（10）：fileSizeExampleを
 
	タイムアウトを：停止する10 //秒= 
 
	FUNCを（）{行く
		私のために：= 0; 私はconcurrencyCountを<; 私は++ { 
			FUNC（インデックスint型）{行く
				{のための
					選択{ 
					：ケース<-stop 
						リターン
					デフォルト：
						休憩
					} 
 
					= doUploadMock（）：RESを
					RES {場合
						atomic.AddInt64（＆totalCountプロパティ、1）
						atomic.AddInt64（＆totalSize、fileSizeExample）
					他} { 
						atomic.AddInt64（＆totalErr、1）
					} 
				} 
			}（I）
		} 
	}（）
 
	T：= time.NewTicker（time.Second）
	指数：= 0 
	{用
		{選択
		ケース<-TC： 
			インデックス++
			tmpCount：= atomic.LoadInt64（＆totalCountプロパティ）
			tmpSize：= atomic.LoadInt64（＆totalSize）
			tmpErr：= atomic.LoadInt64（＆totalErr）
			fmt.Printf（「吞吐率た：％d、成功率：％D \ nは」tmpSize / Int64型（指数）、tmpCount * 100 /（tmpCount + tmpErr））
			であれば、インデックス>タイムアウト{ 
				t.Stop（）
				近い（停止）
				リターン
			} 
		} 
 
	} 
}
いくつかの一般的な同時実行モデルの枠組みをgolang

おすすめ
