av激情亚洲男人的天堂国语,日韩欧美精品一中文字幕,无码av一区二区三区无码,国产又色又爽又刺激的a片,国产又色又爽又刺激的a片

一篇帶給你Go語言的并發(fā)

[[407073]]

并發(fā)

前言

在學(xué)習(xí) Go 的并發(fā)之前，先復(fù)習(xí)一下操作系統(tǒng)的基礎(chǔ)知識。

10年的安州網(wǎng)站建設(shè)經(jīng)驗，針對設(shè)計、前端、開發(fā)、售后、文案、推廣等六對一服務(wù)，響應(yīng)快，48小時及時工作處理。營銷型網(wǎng)站建設(shè)的優(yōu)勢是能夠根據(jù)用戶設(shè)備顯示端的尺寸不同，自動調(diào)整安州建站的顯示方式，使網(wǎng)站能夠適用不同顯示終端，在瀏覽器中調(diào)整網(wǎng)站的寬度，無論在任何一種瀏覽器上瀏覽網(wǎng)站，都能展現(xiàn)優(yōu)雅布局與設(shè)計，從而大程度地提升瀏覽體驗。創(chuàng)新互聯(lián)公司從事“安州網(wǎng)站設(shè)計”,“安州網(wǎng)站推廣”以來，每個客戶項目都認(rèn)真落實執(zhí)行。

并發(fā)與并行

先來理一理并發(fā)與并行的區(qū)別。

  • 并行：指的是在同一時間，多個程序在不同的 CPU 上共同運行，互相之間并沒有對 CPU 資源進(jìn)行競爭。比如，我在看書的時候，左手用來翻書，右手做筆記，兩者可以同時進(jìn)行。
  • 并發(fā)：如果系統(tǒng)只有一個 CPU，有多個程序要運行，系統(tǒng)只能將 CPU 的時間劃分為多個時間片，然后分配給不同的程序。比如，我看書的時候，只能用右手翻完書之后，才能騰出手來做筆記。

可是明確的是并發(fā)≠并行，但是只要 CPU 運行足夠快，每個時間片劃分足夠小，就會給人們造成一種假象，認(rèn)為計算機(jī)在同一時刻做了多個事情。

進(jìn)程、線程、協(xié)程

進(jìn)程是一個程序執(zhí)行的過程，也是系統(tǒng)進(jìn)行資源分配和調(diào)度的基本單位。簡單來說，一個進(jìn)程就是我們電腦上某個獨立運行的程序。

而線程是系統(tǒng)能夠調(diào)度的最小單位，它被包含在進(jìn)程里面，是進(jìn)程中的實際運作單位，一個進(jìn)程可以包含多個線程?？梢詫⑦M(jìn)程理解為一個工廠，而工廠里面的工人就是線程。就像工廠里面必須要有一個工人才能工作一樣，每個進(jìn)程里面也必須有一個線程才能工作。比如，JavaScript 就被成為單線程的語言，說明 JavaScript 工廠里面只有一個打工人，這個打工人就是工頭，稱為主線程。多線程的進(jìn)程中也會有一個主線程，主線程一般隨著進(jìn)程一起創(chuàng)建和銷毀。

進(jìn)程與線程都是操作系統(tǒng)上的概念，程序中如果要進(jìn)行進(jìn)程或者線程的切換，在切換的過程中，需要先保存當(dāng)線程的狀態(tài)，然后恢復(fù)另一個線程的狀態(tài)，這是需要耗費時間的，如果是進(jìn)程的切換還可能跨 CPU，無法利用 CPU 緩存，導(dǎo)致進(jìn)程比線程的切換成本更加高昂。

所以，除了系統(tǒng)級別的內(nèi)核線程外，一些程序中創(chuàng)建了用戶線程這一說，這么做可以減少與操作系統(tǒng)交互，將線程的切換控制在程序內(nèi)，這種用戶態(tài)的線程被稱為協(xié)程。用戶線程的切換完全由程序控制，實際上使用的內(nèi)核線程就只存在一個，內(nèi)核線程與用戶線程之間的關(guān)系為一對多。雖然這樣做可以減少線程上下文切換帶來的開銷，但是，無法避免阻塞的問題。一旦某個用戶線程被阻塞會導(dǎo)致內(nèi)核線程的阻塞，無法進(jìn)行用戶線程進(jìn)行切換，從而整個進(jìn)程都被掛起，

協(xié)程

Go 語言中的線程模型既不是使用內(nèi)核線程，也不是完全的用戶線程，而是一種混合型的線程模型。用戶線程與內(nèi)核線程的對應(yīng)關(guān)系為多對多，用戶線程與內(nèi)核線程動態(tài)關(guān)聯(lián)，當(dāng)某個線程出現(xiàn)阻塞的時候，可以動態(tài)切換到另外的內(nèi)核線程上。

G-P-M模型

上面只是 Go 語言中抽象層面的線程模型，具體是如何進(jìn)行線程調(diào)度的，還是看看 Go 語言的代碼。

 
 
 
 
    
  
  
  
  
  1. func log(msg string) { 
    2. 
  
  
  
  
  2.  fmt.Println(msg) 
    3. 
  
  
  
  
  3. } 
    4. 
  
  
  
  
  4. func main() { 
    5. 
  
  
  
  
  5.  log("hello") 
    6. 
  
  
  
  
  6.  go log("world") 
    7. 
  
  
  
  
  7. } 
    8.

之前的文章介紹過，Go 程序在運行時，默認(rèn)以 main 函數(shù)為入口，main 函數(shù)中運行的代碼會到一個 goroutine 中運行。如果我們在調(diào)用的函數(shù)前，加上一個 go 關(guān)鍵詞，那么這個函數(shù)就放到另外一個 goroutine 中運行。

這里說的 goroutine 就是 Go 語言中的用戶線程，也就是協(xié)程。Go 語言在運行時，會建立一個 G-P-M 模型，這個模型專門負(fù)責(zé) goroutine 的調(diào)度。

  • G：gotoutine(用戶線程);
  • P：processor(邏輯處理器);
  • M：machine(機(jī)器資源);

每個 goroutine 都會放到一個 goroutine 隊列中，由于是用戶自主創(chuàng)建，上下文的切換成本極低。P(processor)的主要作用是管理用戶線程，將 goroutine 合理的安排到內(nèi)核線程上，也就是這個模型的 M。通常情況下，G 的數(shù)量遠(yuǎn)遠(yuǎn)多于 M。

Goroutine

如果你有運行過上面的代碼，你會發(fā)現(xiàn)，go 關(guān)鍵詞后的函數(shù)并沒有真正執(zhí)行。

 
 
 
 
    
  
  
  
  
  1. func log(msg string) { 
    2. 
  
  
  
  
  2.  fmt.Println(msg) 
    3. 
  
  
  
  
  3. } 
    4. 
  
  
  
  
  4. func main() { 
    5. 
  
  
  
  
  5.  log("hello") 
    6. 
  
  
  
  
  6.  go log("world") 
    7. 
  
  
  
  
  7. } 
    8.

運行后，終端只輸出了 hello，并沒有輸出 world。

這是因為 main 函數(shù)會在主 goroutine 中運行，類似于主線程，而每個 go 語句會啟動一個新的 goroutine，啟動后的 goroutine 并不會直接執(zhí)行，而是會放入一個 G 隊列中，等待 P 的分配。但是主 goroutine 結(jié)束后，就意味著程序結(jié)束了，G 隊列中的 goroutine 還沒有等到執(zhí)行時間。所以，go 語句后的函數(shù)是一個異步的函數(shù)，go 語句調(diào)用后，會立即去執(zhí)行后面的語句，而不會等待 go 語句后的函數(shù)執(zhí)行。

如果要 world 輸出，我們可以在 main 函數(shù)后面加一個休眠，延長主 goroutine 的執(zhí)行時間。

 
 
 
 
    
  
  
  
  
  1. import ( 
    2. 
  
  
  
  
  2.  "fmt" 
    3. 
  
  
  
  
  3.  "time" 
    4. 
  
  
  
  
  4. ) 
    5. 
  
  
  
  
  5. func log(msg string) { 
    6. 
  
  
  
  
  6.  fmt.Println(msg) 
    7. 
  
  
  
  
  7. } 
    8. 
  
  
  
  
  8. func main() { 
    9. 
  
  
  
  
  9.  fmt.Println() 
    10. 
  
  
  
  
  10.  log("hello") 
    11. 
  
  
  
  
  11.  go log("world") 
    12. 
  
  
  
  
  12.  time.Sleep(time.Millisecond * 500) 
    13. 
  
  
  
  
  13. } 
    14.

通道

多線程編程中，由于各個線程之間需要共享數(shù)據(jù)，一般采用的是共享內(nèi)存的方案。但是這么做，勢必會出現(xiàn)多個線程同時修改同一份數(shù)據(jù)情況，為了保證數(shù)據(jù)的安全性，需要為數(shù)據(jù)加鎖，處理起來就比較麻煩。

所以在 Go 語言社區(qū)有一句名言：

不要通過共享內(nèi)存來通信，而應(yīng)該通過通信來共享內(nèi)存。

創(chuàng)建通道

這里說的通信的方式，就是 Go 語言中的通道(channel)。通道是 Go 語言中的一種特殊類型，需要通過 make 方法創(chuàng)建一個通道。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan int) // 創(chuàng)建一個 int 類型的通道 
    2.

創(chuàng)建通道的時候，需要加上一個類型，表示該通道傳輸數(shù)據(jù)的類型。也可以通過指定一個空接口的方式，創(chuàng)建一個可以傳送任意數(shù)據(jù)的通道。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan interface{}) 
    2.

創(chuàng)建的通道分為無緩存通道和有緩存通道，make 方法的第二個參數(shù)表示可緩存的數(shù)量(如果傳入 0，效果和不傳一樣)。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan string, 0) // 無緩存通道，傳入 
    2. 
  
  
  
  
  2. ch := make(chan string, 1) 
    3.

發(fā)送和接收數(shù)據(jù)

通道創(chuàng)建后，通過 <- 符號來接收和發(fā)送數(shù)據(jù)。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan string) 
    2. 
  
  
  
  
  2. ch <- "hello world" // 發(fā)送一個字符串 
    3. 
  
  
  
  
  3. msg := <- ch // 接收之前發(fā)送的字符串 
    4.

實際在這個代碼運行的時候，會提示一個錯誤。

 
 
 
 
    
  
  
  
  
  1. fatal error: all goroutines are asleep - deadlock! 
    2.

表明當(dāng)前的 goroutine 處于掛起狀態(tài)，并且后續(xù)不會有響應(yīng)，只能直接中斷程序。因為這里創(chuàng)建的是無緩存通道，發(fā)送數(shù)據(jù)后通道不會將數(shù)據(jù)緩存在通道中，導(dǎo)致后面要找通道要數(shù)據(jù)的時候無法正常從通道中獲取數(shù)據(jù)。我們可以將通道的緩存設(shè)置為 1，讓通道可以緩存一個數(shù)據(jù)在里面。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan string, 1) 
    2. 
  
  
  
  
  2. ch <- "hello world" // 發(fā)送一個字符串 
    3. 
  
  
  
  
  3. msg := <- ch // 接收之前發(fā)送的字符串 
    4. 
  
  
  
  
  4. fmt.Println(msg) 
    5.

但是如果發(fā)送的數(shù)據(jù)超出了緩存數(shù)量，或者接受數(shù)據(jù)時，緩存里面已經(jīng)沒有數(shù)據(jù)了，依然會報錯。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan string, 1) 
    2. 
  
  
  
  
  2. ch <- "hello world" 
    3. 
  
  
  
  
  3. ch <- "hello world" 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. // fatal error: all goroutines are asleep - deadlock! 
    6. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. ch := make(chan string, 1) 
    2. 
  
  
  
  
  2. ch <- "hello world" 
    3. 
  
  
  
  
  3. <- ch 
    4. 
  
  
  
  
  4. <- ch 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // fatal error: all goroutines are asleep - deadlock! 
    7.

協(xié)程中使用通道

那么無緩存的通道中，應(yīng)該怎么發(fā)送和接收數(shù)據(jù)呢?這就需要將通道與協(xié)程進(jìn)行結(jié)合，也就是 Go 語言中常用的并發(fā)的開發(fā)模式。

無緩存的通道在收發(fā)數(shù)據(jù)時，由于一次只能同步的發(fā)送一個數(shù)據(jù)，會在兩個 goroutine 間反復(fù)橫跳，通道在接受數(shù)據(jù)時，會阻塞當(dāng)前 goroutine，直到通道在另一個 goroutine 發(fā)送了數(shù)據(jù)。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan string) // 創(chuàng)建一個無緩存通道 
    2. 
  
  
  
  
  2. temp := "我在地球" 
    3. 
  
  
  
  
  3. go func () {   
    4. 
  
  
  
  
  4.  // 接收一個字符串 
    5. 
  
  
  
  
  5.  ch <- "hello world" 
    6. 
  
  
  
  
  6.  temp = "進(jìn)入了異次元" 
    7. 
  
  
  
  
  7. }() 
    8. 
  
  
  
  
  8. // 運行到這里會被阻塞 
    9. 
  
  
  
  
  9. // 直到通道在另一個 goroutine 發(fā)送了數(shù)據(jù) 
    10. 
  
  
  
  
  10. msg := <- ch 
    11. 
  
  
  
  
  11. fmt.Println(msg) 
    12. 
  
  
  
  
  12. fmt.Println("temp =>", temp) 
    13.

為了證明通道在接收數(shù)據(jù)時會被阻塞，我們可以在前面加上一個 temp 變量，然后在另外的 goroutine 中修改這個變量，看最后輸出的值是否被修改，以此證明通道在接受數(shù)據(jù)時是否發(fā)生了阻塞。

運行結(jié)果已經(jīng)證明，當(dāng)通道接收數(shù)據(jù)時，阻塞了主 goroutine 的執(zhí)行。除了主動的從通道里面一條條的獲取數(shù)據(jù)，還可以通過 range 的方式循環(huán)獲取數(shù)據(jù)。

 
 
 
 
    
  
  
  
  
  1. ch := make(chan string) 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. go func() { 
    4. 
  
  
  
  
  4.   for i := 0; i < 5; i++ { 
    5. 
  
  
  
  
  5.     ch <- fmt.Sprintf("數(shù)據(jù) %d", i) 
    6. 
  
  
  
  
  6.   } 
    7. 
  
  
  
  
  7.   close(ch) 
    8. 
  
  
  
  
  8. }() 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. for data := range ch { 
    11. 
  
  
  
  
  11.   fmt.Println("接收 =>", data) 
    12. 
  
  
  
  
  12. } 
    13.

如果使用 range 循環(huán)讀取通道中的數(shù)據(jù)時，在數(shù)據(jù)發(fā)送完畢時，需要調(diào)用 close(ch) ，將通道關(guān)閉。

實戰(zhàn)

在了解了前面的基礎(chǔ)知識之后，我們可以通過協(xié)程 + 通道的寫一段爬蟲，來實戰(zhàn)一下 Go 語言的并發(fā)能力。

首先確定爬蟲需要爬取的網(wǎng)站，由于個人比較喜歡看電影，所以決定爬一爬豆瓣的電影 TOP 榜單。

其域名為 https://movie.douban.com/top250，翻到第二頁后，域名為 https://movie.douban.com/top250?start=25 ，第三頁的域名為 https://movie.douban.com/top250?start=50，說明每次這個 TOP 榜單每頁會有 25 部電影，每次翻頁就給 start 參數(shù)加上 25。

 
 
 
 
    
  
  
  
  
  1. const limit = 25 // 每頁的數(shù)量為 25 
    2. 
  
  
  
  
  2. const total = 100 // 爬取榜單的前 100 部電影 
    3. 
  
  
  
  
  3. const page = total / limit // 需要爬取的頁數(shù) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. func main() { 
    6. 
  
  
  
  
  6.  var start int 
    7. 
  
  
  
  
  7.  var url string 
    8. 
  
  
  
  
  8.  for i :=0; i < page; i++ { 
    9. 
  
  
  
  
  9.     start := i * limit 
    10. 
  
  
  
  
  10.     // 計算得到所有的域名 
    11. 
  
  
  
  
  11.     url := "https://movie.douban.com/top250?start=" + strconv.Itoa(start) 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13. } 
    14.

然后，我們可以構(gòu)造一個 fetch 函數(shù)，用于請求對應(yīng)的頁面。

 
 
 
 
    
  
  
  
  
  1. func fetch(url string) { 
    2. 
  
  
  
  
  2.   // 構(gòu)造請求體 
    3. 
  
  
  
  
  3.  req, _ := http.NewRequest("GET", url, nil) 
    4. 
  
  
  
  
  4.   // 由于豆瓣會校驗請求的 Header 
    5. 
  
  
  
  
  5.   // 如果沒有 User-Agent，http code 會返回 418 
    6. 
  
  
  
  
  6.  req.Header.Add("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36") 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.   // 發(fā)送請求 
    9. 
  
  
  
  
  9.  client := &http.Client{} 
    10. 
  
  
  
  
  10.  rsp, _ := client.Do(req) 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.   // 斷開連接 
    13. 
  
  
  
  
  13.  defer rsp.Body.Close() 
    14. 
  
  
  
  
  14. } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16. func main() { 
    17. 
  
  
  
  
  17.  for i :=0; i < page; i++ { 
    18. 
  
  
  
  
  18.     url := …… 
    19. 
  
  
  
  
  19.   go fetch(url, ch) 
    20. 
  
  
  
  
  20.  } 
    21. 
  
  
  
  
  21. } 
    22.

然后使用 goquery 來解析 HTML，提取電影的排名以及電影名。

 
 
 
 
    
  
  
  
  
  1. // 第二個參數(shù)為與主goroutine 溝通的通道 
    2. 
  
  
  
  
  2. func fetch(url string, ch chan string) { 
    3. 
  
  
  
  
  3.   // 省略部分代碼 …… 
    4. 
  
  
  
  
  4.  rsp, _ := client.Do(req) 
    5. 
  
  
  
  
  5.   // 斷開連接 
    6. 
  
  
  
  
  6.  defer rsp.Body.Close() 
    7. 
  
  
  
  
  7.   // 解析 HTML 
    8. 
  
  
  
  
  8.  doc, _ := goquery.NewDocumentFromReader(rsp.Body) 
    9. 
  
  
  
  
  9.  // 提取 HTML 中的電影排行與電影名稱 
    10. 
  
  
  
  
  10.  doc.Find(".item").Each(func(_ int, s *goquery.Selection) { 
    11. 
  
  
  
  
  11.   num := s.Find(".pic em").Text() 
    12. 
  
  
  
  
  12.   title := s.Find(".title::first-child").Text() 
    13. 
  
  
  
  
  13.     // 將電影排行與名稱寫入管道中 
    14. 
  
  
  
  
  14.   ch <- fmt.Sprintf("top %s: %s\n", num, title) 
    15. 
  
  
  
  
  15.  }) 
    16. 
  
  
  
  
  16. } 
    17.

最后，在主 goroutine 中創(chuàng)建通道，以及接收通道中的數(shù)據(jù)。

 
 
 
 
    
  
  
  
  
  1. func main() { 
    2. 
  
  
  
  
  2.   ch := make(chan string) 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  for i :=0; i < page; i++ { 
    5. 
  
  
  
  
  5.     url := …… 
    6. 
  
  
  
  
  6.   go fetch(url, ch) 
    7. 
  
  
  
  
  7.  } 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  for i :=0; i < total; i++ { 
    10. 
  
  
  
  
  10.   top := <- ch // 接收數(shù)據(jù) 
    11. 
  
  
  
  
  11.   fmt.Println(top) 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13. } 
    14.

最后的執(zhí)行結(jié)果如下：

可以看到由于是并發(fā)執(zhí)行，輸出的順序是亂序。

完整代碼

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import ( 
    4. 
  
  
  
  
  4.  "fmt" 
    5. 
  
  
  
  
  5.  "github.com/PuerkitoBio/goquery" 
    6. 
  
  
  
  
  6.  "net/http" 
    7. 
  
  
  
  
  7.  "strconv" 
    8. 
  
  
  
  
  8. ) 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. const limit = 25 
    11. 
  
  
  
  
  11. const total = 100 
    12. 
  
  
  
  
  12. const page = total / limit 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. func fetch(url string, ch chan string) { 
    15. 
  
  
  
  
  15.  req, _ := http.NewRequest("GET", url, nil) 
    16. 
  
  
  
  
  16.  req.Header.Add("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36") 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.  client := &http.Client{} 
    19. 
  
  
  
  
  19.  rsp, _ := client.Do(req) 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.  defer rsp.Body.Close() 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.  doc, _ := goquery.NewDocumentFromReader(rsp.Body) 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.  doc.Find(".item").Each(func(_ int, s *goquery.Selection) { 
    26. 
  
  
  
  
  26.   num := s.Find(".pic em").Text() 
    27. 
  
  
  
  
  27.   title := s.Find("span.title::first-child").Text() 
    28. 
  
  
  
  
  28.   ch <- fmt.Sprintf("top %s: %s\n", num, title) 
    29. 
  
  
  
  
  29.  }) 
    30. 
  
  
  
  
  30. } 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32. func main() { 
    33. 
  
  
  
  
  33.  ch := make(chan string) 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35.  for i :=0; i < page; i++ { 
    36. 
  
  
  
  
  36.   start := i * limit 
    37. 
  
  
  
  
  37.   url := "https://movie.douban.com/top250?start=" + strconv.Itoa(start) 
    38. 
  
  
  
  
  38.   go fetch(url, ch) 
    39. 
  
  
  
  
  39.  } 
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41.  for i :=0; i < total; i++ { 
    42. 
  
  
  
  
  42.   top := <- ch 
    43. 
  
  
  
  
  43.   fmt.Println(top) 
    44. 
  
  
  
  
  44.  } 
    45. 
  
  
  
  
  45. } 
    46.

本文題目：一篇帶給你Go語言的并發(fā)
文章起源：http://uogjgqi.cn/article/coojdip.html
掃二維碼與項目經(jīng)理溝通

我們在微信上24小時期待你的聲音

解答本文疑問/技術(shù)咨詢/運營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流