，大概提了一下消息的持久化,--mem-queue-size 設置為 0，所有的消息將會存儲到磁盤。
總有人說nsq的持久化問題，消除疑慮的方法就是閱讀原碼做benchmark測試，個人感覺nsq還是很靠譜的。
nsq自己實現了一個先進先出的消息文件隊列是把消息保存到本地文件內，很值得分析一下他的實現過程。

整體處理邏輯

go-diskqueue 會啟動一個gorouting進行讀寫數據也就是方法ioLoop
會根據你設置的參數來進行數據的讀寫，流程圖如下

這個圖畫的也不是特別的準確 ioLoop 用的是 select 並不是if else 當有多個條件為true時，會隨機選一個進行執行

nsq 生成的數據大致如下：

xxxx.diskqueue.meta.dat 元數據保存了未讀消息的長度，讀取和存入數據的編號和讀取位置
xxxx.diskqueue.編號.dat 消息保存的文件，每一個消息的存儲：4Byte消息的長度+消息

參數說明

一些主要的參數和約束說明
這些參數的使用在後面的處理邏輯中會提到

// diskQueue implements a filesystem backed FIFO queue
type diskQueue struct {
    // run-time state (also persisted to disk)
    // 讀取數據的位置    
    readPos      int64
    // 寫入數據的位置
    writePos     int64
    // 讀取文件的編號    
    readFileNum  int64
    // 寫入文件的編號
    writeFileNum int64
    // 未處理的消息總數    
    depth        int64

    // instantiation time metadata
    // 每個文件的大小限制    
    maxBytesPerFile int64 // currently this cannot change once created
    // 每條消息的最小大小限制    
    minMsgSize      int32
    // 每條消息的最大大小限制    
    maxMsgSize      int32
    // 緩存消息有多少條後進行寫入    
    syncEvery       int64         // number of writes per fsync
    // 自動寫入消息文件的時間間隔    
    syncTimeout     time.Duration // duration of time per fsync
    exitFlag        int32
    needSync        bool

    // keeps track of the position where we have read
    // (but not yet sent over readChan)
    // 下一條消息的位置    
    nextReadPos     int64
    // 下一條消息的文件編號    
    nextReadFileNum int64

    // 讀取的文件
    readFile  *os.File
    // 寫入的文件    
    writeFile *os.File
    // 讀取的buffer    
    reader    *bufio.Reader
    // 寫入的buffer    
    writeBuf  bytes.Buffer

    // exposed via ReadChan()
    // 讀取數據的channel    
    readChan chan []byte

    //.....
}

數據

元數據

讀寫數據信息的元數據保存在xxxxx.diskqueue.meta.data文件內主要用到代碼里的字段如下
未處理的消息總數 depth
讀取文件的編號 readFileNum 讀取數據的位置 readPos
寫入文件的編號 writeFileNum 寫入數據的位置 writePos
真實數據如下

15
0,22
3,24

保存元數據信息

func (d *diskQueue) persistMetaData() error {
    // ...
    fileName := d.metaDataFileName()
    tmpFileName := fmt.Sprintf("%s.%d.tmp", fileName, rand.Int())
    // write to tmp file
    f, err = os.OpenFile(tmpFileName, os.O_RDWR|os.O_CREATE, 0600)
    // 元數據信息
    _, err = fmt.Fprintf(f, "%d\n%d,%d\n%d,%d\n",
        atomic.LoadInt64(&d.depth),
        d.readFileNum, d.readPos,
        d.writeFileNum, d.writePos)
    // 保存
    f.Sync()
    f.Close()
    // atomically rename
    return os.Rename(tmpFileName, fileName)
}

得到元數據信息

func (d *diskQueue) retrieveMetaData() error {
    // ...
    fileName := d.metaDataFileName()
    f, err = os.OpenFile(fileName, os.O_RDONLY, 0600)
    // 讀取數據並賦值
    var depth int64
    _, err = fmt.Fscanf(f, "%d\n%d,%d\n%d,%d\n",
        &depth,
        &d.readFileNum, &d.readPos,
        &d.writeFileNum, &d.writePos)
    //...
    atomic.StoreInt64(&d.depth, depth)
    d.nextReadFileNum = d.readFileNum
    d.nextReadPos = d.readPos
    return nil
}

消息數據

寫入一條數據

ioLoop 中發現有數據寫入時,會調用writeOne方法，把消息保存到文件內

        select {
        // ...
        case dataWrite := <-d.writeChan:
            count++
            d.writeResponseChan <- d.writeOne(dataWrite)
        // ...

func (d *diskQueue) writeOne(data []byte) error {
    var err error

    if d.writeFile == nil {
        curFileName := d.fileName(d.writeFileNum)
        d.writeFile, err = os.OpenFile(curFileName, os.O_RDWR|os.O_CREATE, 0600)
        // ...
        if d.writePos > 0 {
            _, err = d.writeFile.Seek(d.writePos, 0)
            // ...
        }
    }

    dataLen := int32(len(data))
    // 判斷消息的長度是否合法
    if dataLen < d.minMsgSize || dataLen > d.maxMsgSize {
        return fmt.Errorf("invalid message write size (%d) maxMsgSize=%d", dataLen, d.maxMsgSize)
    }
    d.writeBuf.Reset()
    // 寫入4字節的消息長度,以大端序保存
    err = binary.Write(&d.writeBuf, binary.BigEndian, dataLen)
    if err != nil {
        return err
    }
    // 寫入消息
    _, err = d.writeBuf.Write(data)
    if err != nil {
        return err
    }

    // 寫入到文件
    _, err = d.writeFile.Write(d.writeBuf.Bytes())
    // ...
    // 計算寫入位置，消息數量加1
    totalBytes := int64(4 + dataLen)
    d.writePos += totalBytes
    atomic.AddInt64(&d.depth, 1)
    // 如果寫入位置大於 單個文件的最大限制， 則持久化文件到硬盤
    if d.writePos > d.maxBytesPerFile {
        d.writeFileNum++
        d.writePos = 0

        // sync every time we start writing to a new file
        err = d.sync()
        // ...
    }
    return err
}

寫入完消息后，會判斷當前的文件大小是否已經已於maxBytesPerFile如果大，就持久化文件到硬盤，然後重新打開一個新編號文件，進行寫入。

什麼時候持久化文件到硬盤

調用sync()方法會持久化文件到硬盤，然後重新打開一個新編號文件，進行寫入。
有幾個地方調用會調用這個方法：

• 一個寫入文件的條數達到了syncEvery的值時，也就是初始化時設置的最大的條數。會調用sync()
• syncTimeout 初始化時設置的同步時間間隔，如果這個時間間隔到了，並且寫入的文件條數>0的時候，會調用sync()
• 還有就是上面說過的writeOne方法，寫入完消息后，會判斷當前的文件大小是否已經已於maxBytesPerFile如果大，會調用sync()
• 當讀取文件時，把整個文件讀取完時，會刪除這個文件並且會把needSync 設置為true，ioLoop 會調用sync()
• 還有就是Close的時候，會調用sync()

func (d *diskQueue) sync() error {
    if d.writeFile != nil {
        // 把數據 flash到硬盤，關閉文件並設置為 nil
        err := d.writeFile.Sync()
        if err != nil {
            d.writeFile.Close()
            d.writeFile = nil
            return err
        }
    }
    // 保存元數據信息
    err := d.persistMetaData()
    // ...
    d.needSync = false
    return nil
}

讀取一條數據

元數據保存着 讀取文件的編號 readFileNum 和讀取數據的位置 readPos
並且diskQueue暴露出了一個方法來，通過channel來讀取數據

func (d *diskQueue) ReadChan() chan []byte {
    return d.readChan
}

ioLoop里，當發現讀取位置小於寫入位置 或者讀文件編號小於寫文件編號，並且下一個讀取位置等於當前位置時才會讀取一條數據，然後放在一個外部全局變量 dataRead 里，並把 讀取的channel 賦值監聽 r = d.readChan，當外部有人讀取了消息，則進行moveForward操作

func (d *diskQueue) ioLoop() {
    var dataRead []byte
    var err error
    var count int64
    var r chan []byte
    for {
        // ...
        if (d.readFileNum < d.writeFileNum) || (d.readPos < d.writePos) {
            if d.nextReadPos == d.readPos {
                dataRead, err = d.readOne()
                if err != nil {
                    d.handleReadError()
                    continue
                }
            }
            r = d.readChan
        } else {
            r = nil
        }

        select {
        // ...
        case r <- dataRead:
            count++
            // moveForward sets needSync flag if a file is removed
            d.moveForward()
        // ...
        }
    }

// ...
}

readOne 從文件里讀取一條消息，4個bit的大小，然後讀取具體的消息。如果讀取位置大於最大文件限制，則close。在moveForward里會進行刪除操作

func (d *diskQueue) readOne() ([]byte, error) {
    var err error
    var msgSize int32
    // 如果readFile是nil，打開一個新的
    if d.readFile == nil {
        curFileName := d.fileName(d.readFileNum)
        d.readFile, err = os.OpenFile(curFileName, os.O_RDONLY, 0600)
        // ...
        d.reader = bufio.NewReader(d.readFile)
    }
    err = binary.Read(d.reader, binary.BigEndian, &msgSize)
    // ...
    readBuf := make([]byte, msgSize)
    _, err = io.ReadFull(d.reader, readBuf)
    totalBytes := int64(4 + msgSize)
    // ...
    d.nextReadPos = d.readPos + totalBytes
    d.nextReadFileNum = d.readFileNum
    // 如果讀取位置大於最大文件限制，則close。在moveForward里會進行刪除操作
    if d.nextReadPos > d.maxBytesPerFile {
        if d.readFile != nil {
            d.readFile.Close()
            d.readFile = nil
        }
        d.nextReadFileNum++
        d.nextReadPos = 0
    }
    return readBuf, nil
}

moveForward方法會查看讀取的編號，如果發現下一個編號 和當前的編號不同時，則刪除舊的文件。

func (d *diskQueue) moveForward() {
    oldReadFileNum := d.readFileNum
    d.readFileNum = d.nextReadFileNum
    d.readPos = d.nextReadPos
    depth := atomic.AddInt64(&d.depth, -1)

    // see if we need to clean up the old file
    if oldReadFileNum != d.nextReadFileNum {
        // sync every time we start reading from a new file
        d.needSync = true

        fn := d.fileName(oldReadFileNum)
        err := os.Remove(fn)
        // ...
    }
    d.checkTailCorruption(depth)

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

  德國車廠戴姆勒（Daimler AG）今年 7 月才與另外 2 家德國汽車大廠奧迪（Audi）及 BMW 結盟，要以 25 億歐元競購 Nokia Here 地圖，據悉目前此 3 家車廠為最接近 Here 地圖的買家，而除了一同收購 Here 地圖業務外，未來這幾家德國車廠的合作，可能還會延伸到車用電池領域。   戴姆勒執行長 Dieter Zetsche 於 9 月 23 日在法蘭克福車展上表示，「德國車廠間有許多共通點」，因此除了 Here 地圖業務外，戴姆勒不排除與德國其他汽車大廠在其他領域上有所合作，甚至對此持開放態度，而下一步可能就是針對電池業務做結盟。   近來戴姆勒似乎頻頻釋出要與其他企業針對不同領域合作的意願，8 月底 Zetsche 才對外透露，考慮與蘋果及 Google 等公司成立合資企業，共同研發自動駕駛車。       （首圖來源：Flickr/ CC BY 2.0）

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

11 月 13 日，GitHub Universe 2019 開發者大會上，公布了大量新功能，包括髮布 GitHub 移動版、GitHub Actions 和 Packages 正式版上市、重新設計了通知體驗，以及宣布建設一個數據倉庫存儲所有公共倉庫一千年…

GitHub App

官方 App 終於來了，在手機上就可以 Review 代碼、處理 Issues、合併 PR 等常用操作。讓你無論身處何處，都可以靈活地推進工作並與團隊保持聯繫（加班）。

目前已經發布 iOS beta 版並上線 TestFlight，連黑暗模式都安排上了。

Android 版還要等段時間推出。

Actions 和 Packages 正式版

去年 Universe 大會上發布的 GitHub Actions，以及今年上半年發布的 GitHub Packages 結束了測試期。

GitHub Actions 是倉庫自帶的自動化構建與部署功能，擁有完整的 CI/CD 解決方案和本機軟件包管理，並且 GitHub Marketplace 上也提供有上千款社區開發的工作流可以使用。

GitHub Packages 是官方推出的包管理功能，實現將源代碼和包在一個地方集成權限管理和統計，託管在 GitHub 上的軟件包，不僅包括詳細信息和下載統計信息，而且還有它們的全部歷史記錄。

現在這兩款功能免費向所有公共倉庫開放，並且可以使用 Actions 將新的軟件包版本自動發布到 GitHub Packages，使用 Actions 觸發軟件包安裝，以及以最小的配置安裝託管在 GitHub Packages 或首選記錄註冊表上的軟件包和映像。通過 Actions 使用相同的 GITHUB_TOKEN 進行所有自動化程序包的上載和下載。

通知功能

以往在一些熱門開源項目中、或者大型團隊中，各種 Issues 和 PR 的通知郵件會無差別充斥在郵箱中，很難將信號和噪音區分開。

官方終於推出了通知功能來解決這個問題，設立了通知收件箱，可以對不同信息進行篩選和分類，讓你聚焦到有價值的信息中。

並且會着重結合官方 App 進行通知推送。

目前該功能是內測階段，如果想體驗可以下載 GitHub App 獲取測試資格。

代碼導航

代碼導航已於今年早些時候在特定存儲庫的有限公測中發布。今天，官方將其提供給 GitHub 上的所有 Ruby，Python 和 Go 存儲庫，並且很快就會有更多的語言。查看任何公共或私有存儲庫上的 “code” 選項卡，以獲取受支持的語言以進行嘗試。

代碼搜索

在接下來的幾個月中，官方將引入一種新的代碼搜索體驗，包括區分大小寫，特殊字符，標記化和其他特定於代碼的搜索條件。

保存你的代碼一千年

官方發布了一項偉大的計劃：將建設一個名為 GitHub Arctic Code Vault 的數據存儲庫，存儲在北極世界檔案館（AWA）中，這是一個長期的檔案設施，位於北極山永久凍土層深 250 米。

GitHub 將在 2020 年 2 月 2 日掃描所有活動公共存儲庫的快照，並將這些數據保存在 Arctic Code Vault 中。

官方博客這樣寫道：

我們與斯坦福圖書館，Long Now 基金會，Internet 檔案館，軟件遺產基金會，Piql，Microsoft Research 和 Bodleian 圖書館建立了合作夥伴關係，以保護全球的開源代碼。我們將通過跨各種數據格式和位置存儲多個副本來保護這種知識，包括一個旨在保存至少一千年的非常長期的檔案庫，稱為 GitHub Arctic Code Vault。

本文屬於原創，首發於微信公眾號「面向人生編程」，如需轉載請後台留言。

關注后回復以下信息獲取更多資源
回復【資料】獲取 Python / Java 等學習資源
回復【插件】獲取爬蟲常用的 Chrome 插件
回復【知乎】獲取最新知乎模擬登錄

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

環境資訊中心外電；姜唯 翻譯；林大利 審校；稿源：ENS

2020年第50屆世界經濟論壇年會將在1月21日於瑞士達沃斯展開，主題是「團結打造永續世界」（Stakeholders for a Cohesive and Sustainable World），呼籲企業提升氣候行動的積極度。會議為期四天，吸引來自世界各地的3,000多名與會者。

今年的會議將有多位年輕的氣候行動者參與，包括17歲的瑞典環保少女童貝里（Greta Thunberg），盼說服世界各國領導人終結化石燃料經濟。

2020年第50屆世界經濟論壇年會將在1月21日於瑞士達沃斯展開。照片來源： （CC BY-SA 2.0）

童貝里等多名行動者1月10日在《衛報》發表評論：「我們要求在今年的論壇上，所有公司、銀行、機構和政府代表立刻停止所有對化石燃料探勘和開採的投資，立刻終止所有化石燃料補貼，並立刻徹底撤資化石燃料，」

「我們要的不是2050年、2030年或是2021年前完成，我們要立刻做，現在馬上做。」

根據2019年熱帶雨林行動網（Rainforest Action Network）、銀行追蹤（BankTrack）、原民環境網絡（Indigenous Environmental Network）、國際石油改革聯盟（Oil Change International）、美國山嶽協會（Sierra Club）和地球榮譽組織（Honor the Earth）共同發表，獲全球160多個組織背書的「」報告，自2015年簽署巴黎氣候協定至今，33家主要跨國銀行總共投資了1.9兆美元於化石燃料，而且過去兩年間，每年的融資額都在增加，其中6000億美元流向了100家最積極擴張的化石燃料公司。

報告顯示，全球主要銀行的商業慣例與政府間氣候變遷專門委員會（IPCC）2018年的全球暖化特別報告形成強烈對比。IPCC的《》描繪出急速淘汰化石燃料的急迫性，並估計到2035年，全球每年對乾淨能源的投資需求為2.4兆美元。

根據國際貨幣基金組織（IMF）的資料，光是在2017年，全世界就花了5.2兆美元在補貼化石燃料，包括煤炭、石油和天然氣。

美國明尼蘇達州的礦業工廠排放有毒氣體。圖片來源：Tony Webster（CC BY 2.0）

世界經濟論壇的主辦單位清楚收到環境行動人士的訊息，並且連續第四年讓會議保持氣候中立。

論壇發言人艾爾奇（Aylin Elci）說：「我們竭盡所能減少排放，從材料和資源的使用著手，提供更多當地、當季和植物性飲食；運輸方面，該論壇的汽車和巴士車隊今年有90％為油電或電動車。」

論壇發言人坎恩（Oliver Cann）表示，論壇無法減去的溫室氣體排放，主辦單位透過投資負碳排計畫來抵消。

自2017年起，世界經濟論壇持續計算年會相關碳排，透過資助全球經過認證的排放抵銷計畫來抵消，包括工作人員和與會者搭機的產生的碳排。坎恩說，除了減少碳排放之外，這些措施還創造了就業機會，改善了生活條件。

為了抵​​消2020年年會的碳排，論壇決定繼續資助兩個關鍵計畫。一是亞馬遜森林砍伐弧線上的「Jacundá」計畫，保護95,000公頃的原始森林並永續生產橡膠、阿薩伊果和巴西堅果。該計畫由社區主導，並在特種巴西保護區中執行，傳統社區在其中有管理資源的權利。

巴西亞馬遜的「Jacundá」原始森林。圖片來源：

第二個計畫是「綠色農場生物燃氣」，利用沼氣池處理產生的甲烷作為能源，殘留物則成為瑞士當地農場的肥料。

此外，論壇還跟瑞士氣候解決方案供應商「南極」公司合作，資助世界各地多個與堆肥、乾淨爐灶、水力和風力發電相關的碳排抵銷計畫：

印度「新德里堆肥」計畫每年將德里水果和蔬菜市場的73,000噸固體廢棄物轉成堆肥。

柬埔寨國家厭氧消化計畫將18,000座農場的廢棄物轉為肥料，也取代了生質爐，自2006年起省下150,000噸的木材。

在馬利，撒哈拉沙漠覆蓋了一半以上的國土。Katene乾淨爐灶計畫在當地的爐具製造工廠創造了400個工作機會，並種植了2400平方公尺的樹木對抗沙漠化。

中國四川省麻咪澤自然保護區中，當地社區砍柴生火煮飯的需求威脅周圍的生物多樣性和大熊貓的棲息地。世界自然基金會的節柴灶推廣計畫正在努力解決這個問題。

永續的水力發電是最有效的發電方式，但建築成本是發展的一大阻礙。 在巴西，Incomex Hydro計畫已經建了三座水力發電廠，生產乾淨能源，每年減少超過83,000噸的二氧化碳，可供應14,000戶住宅電力。

減少排放仍然是世界經濟論壇2020年年會永續發展工作的重點，是其組織永續發展戰略的一部分，目的是透過抵消無法避免的排放，促進瑞士海內外的永續發展。

在2020年年會召開之前，原民環境網執行總監高圖斯（Tom Goldtooth）提醒仍在投資化石燃料的銀行：「這些銀行所投資的未來，將損害未來七代以上子子孫孫的福祉。」

World Economic Forum 2020 Aims for Sustainability DAVOS-KLOSTERS, Switzerland, January 12, 2020 (ENS)

This year’s annual meeting of the World Economic Forum will call on corporations to raise their ambitions for climate action under the theme Stakeholders for a Cohesive and Sustainable World. The meeting’s 50th edition, opening January 21 and running for four days in Davos-Klosters, will bring together over 3,000 participants from throughout the world.

Young climate activists, including Swedish climate activist Greta Thunberg, 17, will be attending the World Economic Forum this year in an effort to convince world leaders to end the fossil fuel economy.

“We demand that at this year’s Forum, participants from all companies, banks, institutions and governments immediately halt all investments in fossil fuel exploration and extraction, immediately end all fossil fuel subsidies and immediately and completely divest from fossil fuels,” wrote Thunberg and other young climate activists in an opinion piece in “The Guardian” newspaper on January 10.

“We don’t want these things done by 2050, 2030 or even 2021, we want this done now – as in right now,” they wrote.

Since the 2015 Paris Agreement on climate, 33 major global banks have collectively poured US$1.9 trillion into fossil fuels, according to a March 2019 report, “Banking on Climate Change” by six nonprofit organizations and endorsed by over 160 organizations around the world.

Released by Rainforest Action Network, BankTrack, Indigenous Environmental Network, Oil Change International, Sierra Club, and Honor the Earth, the report reveals that 33 global banks have provided US$1.9 trillion to fossil fuel companies since the adoption of the Paris climate accord at the end of 2015. The amount of financing has risen in each of the past two years.

Of this total, $600 billion went to 100 companies that are most aggressively expanding fossil fuels. The report shows that the business practices of the world’s major banks stand in contrast to a 2018 special report on global warming by the Intergovernmental Panel on Climate Change (IPCC). That report, “Global Warming of 1.5 °C,” outlined the critical need for a rapid phase-out of fossil fuels and estimated that the world’s clean energy investment needs are $2.4 trillion per year up to 2035.

In 2017 alone, the world spent $5.2 trillion subsidizing fossil fuels – coal, oil and gas – according to the International Monetary Fund.

The organizers of the World Economic Forum have already got the message. For the fourth year in a row, the annual meeting will be climate neutral.

“We do everything we can to reduce emissions in the first place,” said Forum spokeswoman Aylin Elci. This involves looking at the use of materials and resources, the food served – more local, seasonal and plant-based than ever before – and transportation. The Forum’s fleet of cars and buses is 90 percent hybrid or electric this year.

All greenhouse gas emissions that the Forum cannot eliminate, organizers offset by investing in plans that reduce emissions levels in the atmosphere, says Forum spokesman Oliver Cann.

The Forum has been calculating and offsetting all emissions connected with the annual meeting, including staff and participant air travel, by funding certified offsetting projects around the world since 2017. Beyond carbon emission reduction, these initiatives also create jobs and improved living conditions, says Cann.

To offset the 2020 Annual Meeting, the Forum has decided to continue supporting two key projects. The Jacundá project in the Amazonian Arc of Deforestation known for its disappearing tropical forest protects an area of 95,000 hectares of native forest and sustainably produced rubber, açai and brazil nuts. The project is community-led and implemented on a specific Brazilian category of protected areas in which traditional communities own the right to manage the resources.

The second project is Biogas for Greener Farms, which uses methane generated by the processing of manure in biogas digesters as energy and the residue as fertilizer for local farms in Switzerland.

Cann details other offsetting projects supported by the Forum in collaboration with South Pole, a provider of global climate solutions headquartered in Zurich, Switzerland with 17 offices around the world.

Waste Composters

Composting New Dehli ensures that solid waste from fruit and vegetable markets in Delhi, India, does not end up in landfills and transforms 73,000 tonnes of it into compost every year.

In Cambodia, the National Biodigester program not only treats waste then used as fertilizer by over 18,000 farms but also replaces biomass stoves, saving 150,000 tonnes of wood since 2006.

Clean Cookstoves

In Mali, Katene Clean Cookstoves created 400 jobs in a local stove manufacturing factory and planted 2,400m2 of trees to counter desertification in a country that is more than half covered by the Sahara Desert.

Communities gathering firewood in China’s Mamize Nature Reserve in Sichuan province threaten the surrounding biodiversity and the habitat of giant pandas, an issue the WWF Mamize Firewood-Saving Cook Stove Project has been working to address.

Clean Energy – Hydro and Wind Power

Sustainable hydro plants are the most efficient way to generate electricity, but their cost can be a barrier to construction. In Brazil, Incomex Hydro has set up three hydro plants, which produce clean energy and reduce over 83,000 tonnes of CO2 a year – the equivalent of electricity for 14,000 houses.

Reducing emissions remains the first priority of the World Economic Forum’s sustainability efforts for the Annual Meeting 2020, which forms part of its broader institutional sustainability strategy.

The aim is to use offsetting to neutralize the emissions that cannot be avoided, in a way that fosters sustainable development in Switzerland and abroad.

In advance of the 2020 annual meeting, Tom Goldtooth, executive director of the Indigenous Environmental Network, has a message for banks that are funding fossil fuel development. “These banks are funding a future that will cost the well-being of the next seven generations of life and beyond.”

※ 全文及圖片詳見：

作者

如果有一件事是重要的，如果能為孩子實現一個願望，那就是人類與大自然和諧共存。

於特有生物研究保育中心服務，小鳥和棲地是主要的研究對象。是龜毛的讀者，認為龜毛是探索世界的美德。

延伸閱讀

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!

目錄

前言
本文主要多方面講解java繼承，旨在讓初學者通俗易懂，至於“我爸是李剛”，反正樓主也不知道誰爸是李剛。
@

1、繼承的概述

1.1、繼承的由來

至於由來簡單一句話：多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行為。

繼承描述的是事物之間的所屬關係，這種關係是 is-a 的關係。

1.2、繼承的定義

繼承：就是子類繼承父類的屬性和行為，使得子類對象具有與父類相同的屬性、相同的行為。子類可以直接訪問父類中的非私有的屬性和行為。

這裏再聲明一點，父類又稱為超類或者基類。而子類又稱為派生類這點很基礎！

1.3、繼承的優點

1. 提高代碼的復用性。
2. 類與類之間產生關係，為多態做了完美的鋪墊（不理解沒關係，之後我會再寫一篇多態的文章）

雖然繼承的優點很多但是Java只支持單繼承，不支持多繼承。

1.4、繼承的格式

通過 extends 關鍵字，可以聲明一個子類繼承另外一個父類，定義格式如下：

  class 父類 {
   ... 
   }
   class 子類 extends 父類 { 
   ... 
   } 

2、關於繼承之後的成員變量

當類之間產生了關係后，其中各類中的成員變量，產生了哪些影響呢？ 關於繼承之後的成員變量要從兩方面下手，一是成員變量不重名方面，二是成員變量重名方面。

2.1、成員變量不重名

如果子類父類中出現不重名的成員變量，這時的訪問是沒有影響的。代碼如下：

  class liGang {
        // 父類中的成員變量。
       String name ="李剛";//------------------------------父類成員變量是name
    }
    class LiXiaoGang extends liGang {
        // 子類中的成員變量
        String name2 ="李小剛";//--------------------------子類成員變量是name2
        // 子類中的成員方法
        public void show() {
            // 訪問父類中的name，
            System.out.println("我爸是"+name);
            // 繼承而來，所以直接訪問。
            // 訪問子類中的name2
            System.out.println("我是"+name2);
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang z = new LiXiaoGang();
            // 調用子類中的show方法
            z.show();
        }
    }
    //演示結果： 我爸是李剛   我是李小剛

2.2、 成員變量重名

如果子類父類中出現重名的成員變量，這時的訪問是有影響的。代碼如下：

class liGang {
        // 父類中的成員變量。
       String name ="李剛";//------------------------------父類成員變量是name
    }
    class LiXiaoGang extends liGang {
        // 子類中的成員變量
        String name ="李小剛";//---------------------------子類成員變量也是name
        // 子類中的成員方法
        public void show() {
            // 訪問父類中的name，
            System.out.println("我爸是"+name);
            // 繼承而來，所以直接訪問。
            // 訪問子類中的name2
            System.out.println("我是"+name);
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang z = new LiXiaoGang();
            // 調用子類中的show方法
            z.show();
        }
    }
    //演示結果： 我爸是李小剛   我是李小剛

子父類中出現了同名的成員變量時，在子類中需要訪問父類中非私有成員變量時，需要使用 super 關鍵字，至於修飾父類成員變量，類似於之前學過的 this 。 使用格式 super.父類成員變量名

this表示當前對象，super則表示父類對象，用法類似！

class liGang {
        // 父類中的成員變量。
       String name ="李剛";
    }
    class LiXiaoGang extends liGang {
        // 子類中的成員變量
        String name ="李小剛";
        // 子類中的成員方法
        public void show() {
            // 訪問父類中的name，
            System.out.println("我爸是"+super.name);
            // 繼承而來，所以直接訪問。
            // 訪問子類中的name2
            System.out.println("我是"+this.name);  //當然this可省略
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang z = new LiXiaoGang();
            // 調用子類中的show方法
            z.show();
        }
    }
    //演示結果： 我爸是李剛   我是李小剛

2.3、關於繼承中成員變量值得思考的一個問題

同學你有沒有想過這樣一個問題。如果父類中的成員變量
非私有：子類中可以直接訪問。
私有：子類是不能直接訪問的。如下：

當然，同學你要自己體驗體驗編譯報錯過程，看圖沒體驗感不得勁，~嘔，你這無處安放的魅力，無理的要求，我佛了，行吧~

  class liGang2 {
        // 父類中的成員變量。
        private String name ="李剛";

    }
    class LiXiaoGang2 extends liGang2 {
        // 子類中的成員變量
        String name ="李小剛";
        // 子類中的成員方法
        public void show() {
            // 訪問父類中的name，
            System.out.println("我爸是"+super.name);//------編譯失敗不能直接訪問父類私有屬性（成員變量）
            // 繼承而來，所以直接訪問。
            // 訪問子類中的name2
            System.out.println("我是"+this.name);  //當然this可省略
        }
    }
public class PrivateVariable {
        public static void main(String[] args) {
            // 創建子類對象
            ExtendDemo.LiXiaoGang z = new ExtendDemo.LiXiaoGang();
            // 調用子類中的show方法
            z.show();
        }
    }

通常開發中編碼時，我們遵循封裝的原則，使用private修飾成員變量，那麼如何訪問父類的私有成員變量呢？其實這個時候在父類中提供公共的getXxx方法和setXxx方法就可以了。代碼如下：

class liGang {
        // 父類中的成員變量。
      private String name ="李剛";

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    class LiXiaoGang extends liGang {
        // 子類中的成員變量
        String name ="李小剛";
        // 子類中的成員方法
        public void show() {
            // 訪問父類中的name，
            System.out.println("我爸是"+super.getName());
            // 繼承而來，所以直接訪問。
            // 訪問子類中的name2
            System.out.println("我是"+this.name);  //當然this可省略
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang z = new LiXiaoGang();
            // 調用子類中的show方法
            z.show();
        }
    }
    //演示結果： 我爸是李剛   我是李小剛

分析如下：

3、關於繼承之後的成員方法

分析完了成員變量，現在我們一起來分析分析成員方法。
想一想，當類之間產生了關係，其中各類中的成員方法，又產生了哪些影響呢？ 同樣我們依舊從兩方面分析。
#### 3.1、成員方法不重名
如果子類父類中出現不重名的成員方法，這時的調用是沒有影響的。對象調用方法時，會先在子類中查找有沒有對 應的方法，若子類中存在就會執行子類中的方法，若子類中不存在就會執行父類中相應的方法。代碼如下：

 class liGang3 {
        // 父類中的成員方法。
       public void zhuangRen1(){//--------------------------父類方法名zhuangRen1
           System.out.println("我叫李剛，人不是我撞的，別抓我，我不認識李小剛");
       }
    }
    class LiXiaoGang3 extends liGang3 {

        // 子類中的成員方法
        public void zhuangRen() {//--------------------------子類方法名zhuangRen
            System.out.println("有本事你們告去，我爸是李剛");  
        }
    }
    public class MemberMethod {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang3 liXiaoGang = new LiXiaoGang3();
            // 調用子類中的show方法
            liXiaoGang.zhuangRen();
            liXiaoGang.zhuangRen1();
        }
    }
    
打印結果：有本事你們告去，我爸是李剛
        我叫李剛，人不是我撞的，別抓我，我不認識李小剛

#### 3.2、成員方法重名 【方法重寫】
成員方法重名大體也可以分兩種情況：

1、方法名相同返回值類型、參數列表卻不相同（優先在子類查找，沒找到就去父類）
2、方法名、返回值類型、參數列表都相同，沒錯這就是重寫(Override)

這裏主要講方法重寫 ：子類中出現與父類一模一樣的方法時（返回值類型，方法名和參數列表都相同），會出現覆蓋效果，也稱為重寫或者複寫。聲明不變，重新實現。 代碼如下：

    class liGang3 {
        // 父類中的成員方法。
       public void zhuangRen(int a){
           System.out.println("我叫李剛，人不是我撞的，別抓我");
       }
    }
    class LiXiaoGang3 extends liGang3 {

        // 子類中的成員方法
        public void zhuangRen(int a) {
            System.out.println("有本事你們告去，我爸是李剛");
        }
    }
    public class MemberMethod {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang3 liXiaoGang = new LiXiaoGang3();
            // 調用子類中的zhuangRen方法
            liXiaoGang.zhuangRen(1);

        }
    }
    結果打印：有本事你們告去，我爸是李剛

#### 3.3、繼承中重寫方法的意義
子類可以根據需要，定義特定於自己的行為。既沿襲了父類的功能名稱，又根據子類的需要重新實現父類方法，從而進行擴展增強。比如李剛會開車，李小剛就牛了，在父類中進行擴展增強還會開車撞人，代碼如下：

 class liGang3 {
        // 父類中的成員方法。
       public void kaiChe(){
           System.out.println("我會開車");
       }
    }
    class LiXiaoGang3 extends liGang3 {
        // 子類中的成員方法
        public void kaiChe(){
            super.kaiChe();
            System.out.println("我還會撞人");
            System.out.println("我還能一撞撞倆婆娘");
        }
    }
    public class MemberMethod {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang3 liXiaoGang = new LiXiaoGang3();
            // 調用子類中的zhuangRen方法
            liXiaoGang.kaiChe();

打印結果：   我會開車
           我還會撞人
           我還能一撞撞倆婆娘
        }
    }

不知道同學們發現了沒有，以上代碼中在子類中使用了 super.kaiChe()；super.父類成員方法，表示調用父類的成員方法。

最後重寫必須注意這幾點：

1、方法重寫時， 方法名與形參列表必須一致。
2、子類方法覆蓋父類方法時，必須要保證子類權限 >= 父類權限。
3、方法重寫時，子類的返回值類型必須要 <= 父類的返回值類型。
4、方法重寫時，子類拋出的異常類型要 <= 父類拋出的異常類型。

粗心的同學看黑板，look 這裏【注意：只有訪問權限是>=，返回值、異常類型都是<=】

下面以修飾權限為例，如下：

4、關於繼承之後的構造方法

為了讓你更好的體會，首先我先編寫一個程序

   class liGang4 {
        // 父類的無參構造方法。
        public liGang4(){
            System.out.println("父類構造方法執行了。。。");
        }
    }
    class LiXiaoGang4 extends liGang4 {
        // 子類的無參構造方法。
       public LiXiaoGang4(){
           System.out.println("子類構造方法執行了====");
       }
    }
    public class ConstructionDemo {
        public static void main(String[] args) {
            // 創建子類對象
            LiXiaoGang4 z = new LiXiaoGang4();

        }
    }

用一分鐘猜想一下結果是什麼，猜好了再看下面結果：

父類構造方法執行了。。。
子類構造方法執行了====

好了，看了結果之後，你可能有疑惑。父類構造器方法怎麼執行了？我們先來分析分析，首先在main方法中實例化了子類對象，接着會去執行子類的默認構造器初始化，這個時候在構造方法中默認會在第一句代碼中添加super();沒錯，他就是開掛般的存在，不寫也存在的！有的調~讀四聲“跳”~皮的同學就會說，你說存在就存在啊，無憑無據 ~呀，你這個該死的靚仔~ 如下：

構造方法的名字是與類名一致的，所以子類是無法繼承父類構造方法的。 構造方法的作用是初始化成員變量的。所以子類的初始化過程中，必須先執行父類的初始化動作。子類的構造方法中默認會在第一句代碼中添加super()，表示調用父類的構造方法，父類成員變量初始化后，才可以給子類使用。

當然我已經強調很多遍了 super() 不寫也默認存在，而且只能是在第一句代碼中,不在第一句代碼中行不行，答案是當然不行，這樣會編譯失敗，如下：

5、關於繼承的多態性支持的例子

直接上代碼了喔

class A{
    public String show(C obj) {
        return ("A and C");
    }

    public String show(A obj) {
        return ("A and A");
    }

}
class B extends A{
    public String show(B obj) {
        return ("B and B");
    }
}
class C extends B{
    public String show(A obj) {
        return ("A and B");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        A a=new A();
        B b=new B();
        C c=new C();
        System.out.println("第一題 " + a.show(a));
        System.out.println("第二題 " + a.show(b));
        System.out.println("第三題 " + a.show(c));
    }
}
運行結果：
        第一題 A and A
        第二題 A and A
        第三題 A and C

其實吧，第一題和第三題都好理解，第二題就有點意思了，會發現A類中沒有B類型這個參數，這個時候，你就應該知道子類繼承就是父類，換句話說就是子類天然就是父類，比如中國人肯定是人，但是人不一定是中國人（可能是火星人也可能是非洲人），所以父類做為參數類型，直接傳子類的參數進去是可以的，反過來，子類做為參數類型，傳父類的參數進去，就需要強制類型轉換。

6、super與this的用法

了解他們的用法之前必須明確一點的是父類空間優先於子類對象產生

在每次創建子類對象時，先初始化父類空間，再創建其子類對象本身。目的在於子類對象中包含了其對應的父類空間，便可以包含其父類的成員，如果父類成員非private修飾，則子類可以隨意使用父類成員。代碼體現在子類的構 造方法調用時，一定先調用父類的構造方法。理解圖解如下：

#### 5.1、 super和this的含義：

super ：代表父類的存儲空間標識(可以理解為父親的引用)。

 

this ：代表當前對象的引用(誰調用就代表誰)。

#### 5.2、 super和this訪問成員

this.成員變量 ‐‐ 本類的
super.成員變量 ‐‐ 父類的
this.成員方法名() ‐‐ 本類的
super.成員方法名() ‐‐ 父類的

#### 5.3、super和this訪問構造方法

this(...) ‐‐ 本類的構造方法
super(...) ‐‐ 父類的構造方法

#### 5.4、super()和this()能不能同時使用?

不能同時使用，this和super不能同時出現在一個構造函數裏面，因為this必然會調用其它的構造函數，其它的構造函數必然也會有super語句的存在，所以在同一個構造函數裏面有相同的語句，就失去了語句的意義，編譯器也不會通過。
#### 5.5、總結一下super與this

子類的每個構造方法中均有默認的super()，調用父類的空參構造。手動調用父類構造會覆蓋默認的super()。 super() 和 this() 都必須是在構造方法的第一行，所以不能同時出現。

到這裏，java繼承你get到了咩，get到了請咩一聲，隨便隨手~點個讚唄~

推薦閱讀本專欄的下一篇java文章

歡迎各位關注我的公眾號，一起探討技術，嚮往技術，追求技術…

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家費用,距離,噸數怎麼算?達人教你簡易估價知識!