摘要：在上篇文章實現簡單爬蟲框架單任務版爬蟲中我們實現了一個簡單的單任務版爬蟲，對于單任務版爬蟲，每次都要請求頁面，然后解析數據，然后才能請求下一個頁面。

在上篇文章Golang實現簡單爬蟲框架（2）——單任務版爬蟲中我們實現了一個簡單的單任務版爬蟲，對于單任務版爬蟲，每次都要請求頁面，然后解析數據，然后才能請求下一個頁面。整個過程中，獲取網頁數據速度比較慢，那么我們就把獲取數據模塊做成并發執行。在項目的基礎上，實現多任務并發版爬蟲。

項目github地址：github.com/NovemberCho… 回滾到相應記錄食用，效果更佳。

首先我們把但任務版爬蟲架構中的Fetcher模塊和Parser模塊合并成一個Worker模塊，然后并發執行Worker模塊

然后得到并發版的架構圖：

在并發版爬蟲中，會同時執行多個Worker，每個Worker任務接受一個Request請求，然后請求頁面解析數據，輸出解析出的Requests和Item

因為又很多Request和Worker，所以還需要Scheduler模塊，負責對請求任務的調度處理

Engine模塊接受Worker發送的Requests和Items，當前我們先把Items打印出，把解析出的Request發送給調度器

其中Engine和Scheduler是一個goroutine，Worker包含多個goroutine，各個模塊之間都是用channel進行連接

先放上重構后的項目文件結構：

2、Worker實現

我們從engine.go中提取下面功能作為Worker模塊，同時把engine.go 更名為simple.go。修改后的simple.go文件請自行調整，或者去github項目源代碼回滾查看。

engine/worker.go

package engine

import (
	"crawler/fetcher"
	"log"
)

// 輸入 Request， 返回 ParseResult
func worker(request Request) (ParseResult, error) {
	log.Printf("Fetching %s
", request.Url)
	content, err := fetcher.Fetch(request.Url)
	if err != nil {
		log.Printf("Fetch error, Url: %s %v
", request.Url, err)
		return ParseResult{}, err
	}
	return request.ParseFunc(content), nil
}

對于每一個Worker接受一個請求，然后返回解析出的內容

請大家根據架構圖來看，效果會更好。

package engine

import "log"

// 并發引擎
type ConcurrendEngine struct {
   Scheduler   Scheduler	// 任務調度器
   WorkerCount int			// 任務并發數量
}

// 任務調度器
type Scheduler interface {
   Submit(request Request) // 提交任務
   ConfigMasterWorkerChan(chan Request)	// 配置初始請求任務
}

func (e *ConcurrendEngine) Run(seeds ...Request) {

   in := make(chan Request)			// scheduler的輸入
   out := make(chan ParseResult)	// worker的輸出
   e.Scheduler.ConfigMasterWorkerChan(in)	// 把初始請求提交給scheduler

   // 創建 goruntine
   for i := 0; i < e.WorkerCount; i++ {
      createWorker(in, out)
   }

   // engine把請求任務提交給 Scheduler
   for _, request := range seeds {
      e.Scheduler.Submit(request)
   }

   itemCount := 0
   for {
      // 接受 Worker 的解析結果
      result := <-out
      for _, item := range result.Items {
         log.Printf("Got item: #%d: %v
", itemCount, item)
         itemCount++
      }

      // 然后把 Worker 解析出的 Request 送給 Scheduler
      for _, request := range result.Requests {
         e.Scheduler.Submit(request)
      }
   }
}

// 創建任務，調用worker，分發goroutine
func createWorker(in chan Request, out chan ParseResult) {
   go func() {
      for {
         request := <-in
         result, err := worker(request)
         if err != nil {
            continue
         }
         out <- result
      }
   }()
}

package scheduler

import "crawler/engine"

type SimpleScheduler struct {
	workerChan chan engine.Request
}

func (s *SimpleScheduler) Submit(request engine.Request) {
	// 為每一個 Request 創建 goroutine
	go func() {
		s.workerChan <- request
	}()
}

// 把初始請求發送給 Scheduler
func (s *SimpleScheduler) ConfigMasterWorkerChan(in chan engine.Request) {
	s.workerChan = in
}

package main

import (
	"crawler/engine"
	"crawler/scheduler"
	"crawler/zhenai/parser"
)

func main() {
	e := engine.ConcurrendEngine{	// 配置爬蟲引擎
		Scheduler:   &scheduler.SimpleScheduler{},
		WorkerCount: 50,
	}
	e.Run(engine.Request{		// 配置爬蟲目標信息
		Url:       "http://www.zhenai.com/zhenghun",
		ParseFunc: parser.ParseCityList,
	})
}

本次博客我們實現一個最簡單的并發版爬蟲，調度器源源不斷的接受任務，一旦有一個worker空閑，就給其分配任務。這樣子有一個缺點，就是我們不知道我們分發出那么多worker的工作情況，對worker的控制力比較弱，所以在下次博客中會用隊列來實現任務調度。

如果想獲取Google工程師深度講解go語言視頻資源的，可以在評論區留下郵箱。

項目的源代碼已經托管到Github上，對于各個版本都有記錄，歡迎大家查看，記得給個star，在此先謝謝大家了