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 插件
回復【知乎】獲取最新知乎模擬登錄

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

【其他文章推薦】

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

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

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

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

目錄

一、需求場景：

在和其他廠商對接的時候，經常會將某數據庫的某些表放開增刪改查（CRUD）的權限給對方，此時，就要新建個用戶，授予某數據庫的某些表CRUD的權限；還有的時候只需授權SELECT權限，其他權限不能授予；

二、操作步驟：

演示所用數據庫版本：SQL Server Management Studio V17.8.1

1、登錄SSMS后選擇【安全性】，右鍵點擊【登錄名】,在彈出的右鍵菜單中選擇【新建登錄名】選項；

2、在【常規】選項卡中，創建登錄名，並設置默認數據庫；

3、在【用戶映射】選顯卡中，勾選數據庫，並設置【架構】；

4、對需要設置操作權限的表進行權限設置，【表】–【屬性】；

數據庫TestDB中已經有兩個表，分別為User和Salary，現在對錶User進行權限設置，將Insert、update、delete、select的權限賦給用戶【zyl】；
1）、表上右鍵選擇【屬性】，選擇【權限】選項卡：

2）、點擊【搜索】，在彈出的框中點擊【瀏覽】，選擇需要設置的用戶；

3）、在上面點擊【確定】后，就可以在【權限】選項卡中看到權限列表，選擇需要的權限點擊確定即可；

4）、當選中【選擇】和【引用】權限時，還可以設置【列權限】；

5、使用【zyl】登錄數據庫，就只能看到User表了；

並且用戶【zyl】只能對錶User進行增刪改查，不能修改表結構；

三、注意事項

1、在權限列表中如果選擇了【設置】這項，那麼再設置【列權限】就沒有意義了，因為查詢已經不受限制了；

如果設置了【列權限】，沒有選擇【設置】權限，那麼select * 就會報錯；

2、除了對錶設置權限外，還可以對視圖、函數等進行權限設置；

在數據庫的【安全性】-【用戶】-【zyl】-【屬性】-【安全對象】；

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

【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

環境資訊中心外電；姜唯 翻譯；林大利 審校；稿源：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/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

1:概述

搜索樹是一種可以進行插入，搜索，刪除等操作的數據結構，可以用作字典或優先級隊列。二叉搜索樹是最簡單的搜索樹。其左子樹的鍵值<=根節點的鍵值，右子樹的鍵值>=根節點的鍵值。

如果共有n個元素,那麼每次操作需要的O(log n)的時間.

 

 

 

常用知識點

• 滿二叉樹 : 一棵深度為k，且有2^k-1個節點的二叉樹，稱為滿二叉樹。這種樹的特點是每一層上的節點數都是最大節點數。
• 完全二叉樹 : 而在一棵二叉樹中，除最後一層外，若其餘層都是滿的，並且最後一層要麼是滿的，要麼在右邊缺少連續若干節點，則此二叉樹為完全二叉樹。具有n個節點的完全二叉樹的深度為floor(log2n)+1。深度為k的完全二叉樹，至少有2^(k-1)個恭弘=叶 恭弘子節點，至多有2^k-1個節點。

2.基本操作

1. 查找(search)
2. 插入(insert)
3. 刪除(remove)

3:操作原理

　　

查找

假設查找的值為x,從根節點的值開始比對,如果小於根節點的值,則往左兒子繼續查找,如果大於根節點的值,則往右兒子繼續查找.依次類推.直到當前節點的值等於要查找的值.

 

　　以查找數值10為例

插入

按照查找的步驟即可找到插入值應該在的位置

 

 

以插入數值6為例

刪除:

有四種情況:

1: // 當前節點無左節點 ,右字節點7覆蓋5, 

: 3: // 當前節點無右節點 ,右字節點7覆蓋5, 

 

 : 4: // 刪除節點5的左節點沒有右節點, 只需要8作為3的右節點 ,3節點覆蓋5

 

 

: 2:  如果以上3中情況都沒有,只需要尋找當前節點的左節點的所有字節點的最大值,用最大值填充5節點 4填充5

 

 

 

 

5:完整代碼

#include <stdio.h> 
#include <stdlib.h>
struct TNode{
    int data;
    struct TNode *lt;
    struct TNode *rt;    
};
struct TNode* insrtTree(struct TNode *t,int key,int i);
void printTree(struct TNode *root);
struct TNode* delTree(struct TNode* t,int key);
int find(struct TNode* t,int key); 
int arr[1000]={0};
int main(){
    int n,m;
    int i,t;
    scanf("%d%d",&n,&m); 
    struct TNode *root=NULL;
    for(i=0;i<n;i++){
        scanf("%d",&arr[i]); 
        root=insrtTree(root,arr[i],i);
    }
    //t=arr[m-1];
    
    /*
    if(arr[m-1]==0){
        printf("Right child");
    }else{
        printf("Light child");
    }*/
    root=delTree(root,10);
    printTree(root);
    return 0;
}

int find(struct TNode* pt,int key){
    if(pt==NULL)return NULL;
    else if(pt->data==key)return 1;
    else if(pt->data>key) return find(pt->lt,key);
    else if(pt->data<key) return find(pt->rt,key);
}
// 刪除節點 
struct TNode* delTree(struct TNode* pt,int key){
    if(pt==NULL)return NULL;
    else if(pt->data>key) pt->lt=delTree(pt->lt,key);//尋找左節點 
    else if(pt->data<key) pt->rt=delTree(pt->rt,key);//尋找右節點
    //  找到節點 處理四種情況  
    else if(pt->lt==NULL){ // 當前節點無左節點 
        struct TNode* curt=pt->rt;
        free(pt);
        return curt;
    }else if(pt->rt==NULL){// 當前節點無右節點 
        struct TNode* curt=pt->lt;
        free(pt);
        return curt;
    }else if(pt->lt->rt==NULL){// 當前節點的左節點無右節點 
        struct TNode* curt=pt->lt;
        curt->rt=pt->rt;
        free(pt);
        return curt;
    }else{ 
    // 以上不滿足就把左兒子的子孫中最大的節點, 即右子樹的右子樹的...右子樹, 
    //提到需要刪除的節點位置
            struct TNode* p;
            for(p=pt->lt;p->rt->rt!=NULL;p=p->rt);
            struct TNode* curt=p->lt;
            p->rt=curt->rt;
            curt->lt=pt->lt;
            curt->rt=pt->rt;
            free(p);
            return curt;
    }
    return pt;
}
struct TNode* insrtTree(struct TNode *t,int key,int i){
    if(t==NULL){ //處理第一個節點 以及子節點為NULL情況 
        t=(struct TNode*)malloc(sizeof(struct TNode));
        t->lt=t->rt=NULL;
        t->data=key;
        return t;
    }
    if(t->data>key){// 插入左子樹情況 
         arr[i]=1;
        t->lt=insrtTree(t->lt,key,i);
    }else{         // 插入右子樹情況
        arr[i]=0;
        t->rt=insrtTree(t->rt,key,i);
    }
    return t;
}
void printTree(struct TNode *root){
    if(root==NULL)return;
    printf("%d ",root->data);
    printTree(root->lt);
    printTree(root->rt);
}

 

說明: 本身學習了 https://blog.csdn.net/li_l_il/article/details/88677927 但是完善了代碼 

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

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※評比前十大台北網頁設計、台北網站設計公司知名案例作品心得分享

※智慧手機時代的來臨，RWD網頁設計已成為網頁設計推薦首選

※評比南投搬家公司費用收費行情懶人包大公開

良心製作，右鍵另存為保存

喜歡可以點個贊哦

Java虛擬機

一、運行時數據區域

線程私有

• 程序計數器

  • 記錄正在執行的虛擬機字節碼指令的地址（如果正在執行的是Native方法則為空），是唯一一個沒有規定OOM（OutOfMemoryError）的區域。

• Java虛擬機棧

  • 每個Java方法在執行的同時會創建一個棧楨用於存儲局部變量表、操作數棧、動態鏈接、方法出口等信息。從方法調用直到執行完成的過程，對應着一個棧楨在Java虛擬機棧中入棧和出棧的過程。（局部變量包含基本數據類型、對象引用reference和returnAddress類型）

• 本地方法棧

  • 本地方法棧與Java虛擬機棧類似，它們之間的區別只不過是本地方法棧為Native方法服務。

線程公有

• Java堆（GC區）（Java Head）

  • 幾乎所有的對象實例都在這裏分配內存，是垃圾收集器管理的主要區域。分為新生代和老年代。對於新生代又分為Eden空間、From Survivor空間、To Survivor空間。

• JDK1.7 方法區（永久代）

  • 用於存放已被加載的類信息、常量、靜態變量、即時編譯器編譯后的代碼等數據。
    對這塊區域進行垃圾回收的主要目的是對常量池的回收和對類的卸載，但是一般難以實現。
    HotSpot虛擬機把它當做永久代來進行垃圾回收。但很難確定永久代的大小，因為它受到很多因素的影響，並且每次Full GC之後永久代的大小都會改變，所以經常拋出OOM異常。
    從JDK1.8開始，移除永久代，並把方法區移至元空間。

  • 運行時常量池

    • 是方法區的一部分
      Class文件中的常量池（編譯器生成的字面量和符號引用）會在類加載后被放入這個區域。
      允許動態生成，例如String類的intern()

• JDK1.8 元空間

  • 原本存在方法區（永久代）的數據，一部分移到了Java堆裏面，一部分移到了本地內存裏面（即元空間）。元空間存儲類的元信息，靜態變量和常量池等放入堆中。

• 直接內存

  • 在NIO中，會使用Native函數庫直接分配堆外內存。

二、HotSpot虛擬機

對象的創建

• 當虛擬機遇到一條new指令時

1. 檢查參數能否在常量池中找到符號引用，並檢查這個符號引用代表的類是否已經被加載、解析和初始過，沒有的話先執行相應的類加載過程。
2. 在類加載檢查通過之後，接下來虛擬機將為新生對象分配內存。
3. 內存分配完成之後，虛擬機需要將分配到的內存空間都初始化為零值（不包括對象頭）。
4. 對對象頭進行必要的設置。
5. 執行構造方法按照程序員的意願進行初始化。

對象的內存布局

• 1. 對象頭
  • 1. 第一部分用於存儲對象自身的運行時數據，如哈希碼、GC分代年齡、鎖狀態標識、線程持有的鎖、偏向線程ID、偏向實現戳等。
  • 1. 第二部分是類型指針，即對象指向它的類元數據的指針（如果使用直接對象指針訪問），虛擬機通過這個指針來確定這個對象是哪個類的實例。
  • 1. 如果對象是一個Java數組的話，還需要第三部分記錄數據長度的數據。
• 1. 實例數據
  • 是對象真正存儲的有效信息，也就是在代碼中定義的各種類型的字段內容。
• 1. 對齊填充
  • 不是必然存在的，僅僅起着佔位符的作用。
    HotSpot需要對象的大小必須是8字節的整數倍。

對象的訪問定位

• 句柄訪問

  • 在Java堆中劃分出一塊內存作為句柄池。
    Java棧上的對象引用reference中存儲的就是對象的句柄地址，而句柄中包含了到對象實例數據的指針和到對象類型數據的指針。
    對象實例數據在Java堆中，對象類型數據在方法區（永久代）中。
    優點：在對象被移動時只會改變句柄中的實例數據指針，而對象引用本身不需要修改。

• 直接指針訪問（HotSpot使用）

  • Java棧上的對象引用reference中存儲的就是對象的直接地址。
    在堆中的對象實例數據就需要包含到對象類型數據的指針。
    優點：節省了一次指針定位的時間開銷，速度更快。

三、垃圾收集

概述

• 垃圾收集主要是針對Java堆和方法區。
  程序計數器、Java虛擬機棧個本地方法棧三個區域屬於線程私有，線程或方法結束之後就會消失，因此不需要對這三個區域進行垃圾回收。

判斷對象是否可以被回收

• 第一次標記（緩刑）

  • 引用計數算法

    • 給對象添加一個引用計數器，當對象增加一個引用時引用計數值++，引用失效時引用計數值–，引用計數值為0時對象可以被回收。

但是它難以解決對象之間的相互循環引用的情況，此時這個兩個對象引用計數值為1，但是永遠無法用到這兩個對象。

- 可達性分析算法（Java使用）

    - 以一系列GC Roots的對象作為起始點，從這些節點開始向下搜索，搜索所走過的路徑稱為引用鏈，當一個對象到GC Roots沒有任何引用鏈相連是，則證明此對象不可用，可以被回收。

GC Roots對象包括

1. 虛擬機棧（棧楨中的本地變量表）中引用的對象。
2. 方法區中共類靜態屬性引用的對象。
3. 方法區中常量引用的對象。
4. 本地方法棧中JNI（即一般說的Native方法）引用的對象。

• 第二次標記

  • 當對象沒有覆蓋finalize()方法，或者finalize()方法已經被虛擬機調用過。
    如果對象在finalize方法中重新與引用鏈上的任何一個對象建立關聯則將不會被回收。

  • finalize()

    • 任何一個對象的finalize()方法都只會被系統調用一次。
      它的出現是一個妥協，運行代價高昂，不確定性大，無法保證各個對象的調用順序。
      finalize()能做的所有工作使用try-finally或者其他方式都可以做的更好，完全可以忘記在這個函數的存在。

方法區的回收

• 在方法區進行垃圾回收的性價比一般比較低。
  主要回收兩部分，廢棄常量和無用的類。

滿足無用的類三個判斷條件才僅僅代表可以進行回收，不是必然關係，可以使用-Xnoclassgc參數控制。

1. 該類的所有實例都已經被回收，也就是Java堆中不存在該類的任何實例。
2. 加載該類的ClassLoader已經被回收。
3. 該類對應的java.lang.Class對象沒有在任何地方被引用，無法在任何地方通過反射訪問到該類的方法。

引用類型

• 1. 強引用
  • 使用new一個新對象的方式來創建強引用。
    只要強引用還存在，被引用的對象則永遠不會被回收。
• 1. 軟引用
  • 使用SoftReference類來實現軟引用。
    用來描述一些還有用但是並非必須的對象，被引用的對象在將要發生內存溢出異常之前會被回收。
• 1. 弱引用
  • 使用WeakReference類來實現弱引用。
    強度比軟引用更弱一些，被引用的對象在下一次垃圾收集時會被回收。
• 1. 虛引用
  • 使用PhantomReference類來實現虛引用。
    最弱的引用關係，不會對被引用的對象生存時間構成影響，也無法通過虛引用來取得一個對象實例。
    唯一目的就是能在這個對象被收集器回收時收到一個系統通知。

垃圾收集算法

• 1. 標記 – 清除
  • 首先標記出所有需要回收的對象，在標記完成后統一回收被標記的對象並取消標記。

不足：

1. 效率問題，標記和清除兩個過程的效率都不高。
2. 空間問題，標記清除之後會產生大量不連續的內存碎片，沒有連續內存容納較大對象而不得不提前觸發另一次垃圾收集。

• 1. 標記 – 整理
  • 和標記 – 清除算法一樣，但標記之後讓所有存活對象都向一段移動，然後直接清理掉端邊界以外的內存。
    解決了標記 – 清除算法的空間問題，但需要移動大量對象，還是存在效率問題。
• 1. 複製
  • 將可用內存按容量劃分為大小相等的兩塊，每次只使用其中的一塊。當這一塊的內存用完了，就將還存活着的對象複製到另外一塊上面，然後再把已使用多的內存空間一次清理掉。
    代價是將內存縮小為原來的一般，太高了。

現在商業虛擬機都採用這種算法用於新生代。
因為新生代中的對象98%都是朝生暮死，所以將內存分為一塊較大的Eden空間和兩塊較小的Survivor空間，每次使用Eden和其中一塊Survivor空間。
當回收時，如果另外一塊Survivor空間沒有足夠的空間存放存活下來的對象時，這些對象將直接通過分配擔保機制進入老年代。

• 1. 分代收集
  • 一般把Java堆分為新生代和老年代。
    在新生代中使用複製算法，在老年代中使用標記 -清除 或者 標記 – 整理 算法來進行回收。

HotSpot的算法實現

• 枚舉根節點（GC Roots）

  • 目前主流Java虛擬機使用的都是準確式GC。
    GC停頓的時候，虛擬機可以通過OopMap數據結構（映射表）知道，在對象內的什麼偏移量上是什麼類型的數據，而且特定的位置記錄著棧和寄存器中哪些位置是引用。因此可以快速且準確的完成GC Roots枚舉。

• 安全點

  • 為了節省GC的空間成本，並不會為每條指令都生成OopMap，只是在“特定的位置”記錄OopMap，這些位置稱為安全點。

程序執行只有到達安全點時才能暫停，到達安全點有兩種方案。

1. 搶斷式中斷（幾乎不使用）。GC時，先把所有線程中斷，如果有線程不在安全點，就恢復該線程，讓他跑到安全點。
2. 主動式中斷（主要使用）。GC時，設置一個標誌，各個線程執行到安全點時輪詢這個標誌，發現標誌為直則掛起線程。

但是當線程sleep或blocked時無法響應JVM的中斷請求走到安全點中斷掛起，所以引出安全區域。

• 安全區域

  • 安全區域是指在一段代碼片段之中，引用關係不會發生變化，是擴展的安全點。

線程進入安全區域時表示自己進入了安全區域，這個發生GC時，JVM就不需要管這個線程。
線程離開安全區域時，檢查系統是否完成GC過程，沒有就等待可以離開安全區域的信號為止，否者繼續執行。

垃圾收集器

• 新生代

  • 1. serial收集器
    • 它是單線程收集器，只會使用一個線程進行垃圾收集工作，更重要的是它在進行垃圾收集時，必須暫停其他所有的工作線程。

優點：對比其他單線程收集器簡單高效，對於單個CPU環境來說，沒有線程交互的開銷，因此擁有最高的單線程收集效率。

它是Client場景下默認新生代收集器，因為在該場景下內存一般來說不會很大。

- 2. parnew收集器

    - 它是Serial收集器的多線程版本，公用了相當多的代碼。

在單CPU環境中絕對不會有比Serial收集器更好的效果，甚至在2個CPU環境中也不能百分之百超越。

它是Server場景下默認的新生代收集器，主要因為除了Serial收集器，只用它能與CMS收集器配合使用。

- 3. parallel scavenge收集器

    - “吞吐優先”收集器，與ParNew收集器差不多。

但是其他收集器的目標是盡可能縮短垃圾收集時用戶線程停頓的時間，而它的目標是達到一個可控制的吞吐量。這裏的吞吐量指CPU用於運行用戶程序的時間佔總時間的比值。

• 老年代

  • 1. serial old收集器
    • 是Serial收集器老年代版本。

也是給Client場景下的虛擬機使用的。

- 5. parallel old收集器

    - 是Parallel Scavenge收集器的老年代版本。

在注重吞吐量已經CPU資源敏感的場合，都可以優先考慮Parallel Scavenge和Parallel Old收集器。

- 6. cms收集器

    - Concurrent Mark Sweep收集器是一種以獲取最短回收停頓時間為目標的收集器。
    - 運作過程

        - 1. 初始標記（最短）。仍需要暫停用戶線程。只是標記一下GC Roots能直接關聯到的對象，速度很快

1. 併發標記（耗時最長）。進行GC Roots Tracing（根搜索算法）的過程。
2. 重新標記。修正併發標記期間因用戶程序繼續運作而導致標記產生變動的那一部分對象的標記記錄。比初始標記長但遠小於併發標記時間。
3. 併發清除

1 和4 兩個步驟並沒有帶上併發兩個字，即這兩個步驟仍要暫停用戶線程。

    - 優缺點

        - 併發收集、低停頓。

1. CMS收集器對CPU資源非常敏感。雖然不會導致用戶線程停頓，但是佔用CPU資源會使應用程序變慢。
2. 無法處理浮動垃圾。在併發清除階段新垃圾還會不斷的產生，所以GC時要控制“-XX:CMSinitiatingOccupancyFraction參數”預留足夠的內存空間給這些垃圾，當預留內存無法滿足程序需要時就會出現”Concurrent Mode Failure“失敗，臨時啟動Serial Old收集。
3. 由於使用標記 – 清除算法，收集之後會產生大量空間碎片。

• 1. g1收集器
  • Garbage First是一款面向服務端應用的垃圾收集器

  • 運作過程

    • 1. 初始標記

1. 併發標記
2. 最終標記
3. 刪選標記

五、類加載機制

概述

• 虛擬機把描述類的數據從Class問價加載到內存，並對數據進行校驗、轉換解析和初始化，最終形成可以被虛擬機直接使用的Java類型。
  Java應用程序的高度靈活性就是依賴運行期動態加載和動態連接實現的。

類的生命周期

• 加載 -> 連接（驗證 -> 準備 -> 解析） -> 初始化 -> 使用 – >卸載

類初始化時機

• 主動引用

  • 虛擬機規範中沒有強制約束何時進行加載，但是規定了有且只有五種情況必須對類進行初始化（加載、驗證、準備都會隨之發生）

1. 遇到new、getstatic、putstatic、invokestatic這四條字節碼指令時沒有初始化。
2. 反射調用時沒有初始化。
3. 發現其父類沒有初始化則先觸發其父類的初始化。
4. 包含psvm（mian（）方法）的那個類。
5. 動態語言支持時，REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄。

• 被動引用

  • 除上面五種情況之外，所有引用類的方式都不會觸發初始化，稱為被動引用。

1. 通過子類引用父類的靜態字段，不會導致子類的初始化。
2. 通過數組定義來引用類，不會觸發此類的初始化。該過程會對數組類進行初始化，數組類是一個由虛擬機自動生成的、直接繼承Object的子類，其中包含數組的屬性和方法，用戶只能使用public的length和clone()。
3. 常量在編譯階段會存入調用類的常量池中，本質上並沒有直接引用到定義常量的類，因此不會觸發定義常量的類的初始化。

類加載過程

• 1. 加載
  • 1. 通過類的全限定名來獲取定義此類的二進制字節流。

1. 將這個字節流所代表的靜態存儲結構轉化為方法區的運行時數據結構。
2. 在內存中生成一個代表這個類的java.lang.Class對象（HotSpot將其存放在方法區中），作為方法區這個類的各種數據的訪問入口。

• 1. 驗證
  • 為了確保Class文件的字節類中包含的信息符合當前虛擬機的要求，並且不會危害虛擬機自身的安全。可以通過-Xverify:none關閉大部分類驗證。

1. 文件格式驗證。確保輸入字節流能正確的解析並存儲於方法區，後面的3個驗證全部基於方法區的存儲結構進行，不會再操作字節流。
2. 元數據驗證。對字節碼描述信息進行語義分析，確保其符合Java語法規範。（Java語法驗證）
3. 字節碼驗證。最複雜，通過數據流和控制流分析，確定程序語義時合法的、符合邏輯的。可以通過參數關閉。（驗證指令跳轉範圍，類型轉換有效等）
4. 符號引用驗證。將符號引用轉化為直接引用，發生在第三個階段——解析階段中發生。

• 1. 準備
  • 類變量是被static修飾的變量，準備階段為類變量分配內存並設置零值（final直接設置初始值），使用的是方法區的內存。
• 1. 解析
  • 將常量池內的符號引用替換為直接引用的過程。
    其中解析過程在某些情況下可以在初始化階段之後再開始，這是為了支持Java的動態綁定。
    解析動作主要針對類或接口、字段、類方法、接口方法、方法類型、方法句柄、和調用點限定符。
• 1. 初始化

  • 初始化階段才真正執行類中定義的Java程序代碼，是執行類構造器 ()方法的過程。
    在準備階段，類變量已經給過零值，而在初始化階段，根據程序員通過程序制定的主觀計劃去初始化類變量和其他資源。

    • ()

      • 類構造器方法。是由編譯器自動收集類中的所有類變量的賦值動作和靜態語句塊中的的語句合併產生的。

1. 不需要顯式調用父類構造器，JVM會保證在子類clinit執行之前，父類的clinit已經執行完成。
2. 接口中不能使用靜態語句塊但仍可以有類變量的賦值操作。當沒有使用父接口中定義的變量時子接口的clinit不需要先執行父接口的clinit方法。接口的實現類也不會執行接口的clinit方法。

3. 虛擬機會保證clinit在多線程環境中被正確的加鎖、同步。其他線性喚醒之後不會再進入clinit方法，同一個類加載器下，一個類型只會初始化一次。

    - <init>()
   
        - 對象構造器方法。Java對象被創建時才會進行實例化操作，對非靜態變量解析初始化。

4. 會顯式的調用父類的init方法，對象實例化過程中對實例域的初始化操作全部在init方法中進行。

類（加載） 器

• 類與類加載器

  • 類加載器實現類的加載動作。
    類加載器和這個類本身一同確立這個類的唯一性，每個類加載器都有獨立的類命名空間。在同一個類加載器加載的情況下才會有兩個類相等。
    相等包括類的Class對象的equals()方法、isAssignableFrom()方法、isInstance()、instanceof關鍵字。

• 類加載器分類

  • 啟動類加載器

    • 由C++語言實現，是虛擬機的一部分。負責將JAVA_HOME/lib目錄中，或者被-Xbootclasspath參數指定的路徑，但是文件名要能被虛擬機識別，名字不符合無法被啟動類加載器加載。啟動類加載器無法被Java程序直接引用。

  • 擴展類加載器

    • 由Java語言實現，負責加載JAVA_HOME/lib/ext目錄，或者被java.ext.dirs系統變量所指定的路徑中的所有類庫，開發者可以直接使用擴展類加載器。

  • 應用程序類加載器

    • 由於這個類加載器是ClassLoader中的getSystemClassLoader()方法的返回值，所以一般也稱他為系統類加載器。負責加載用戶類路徑（ClassPath）上所指定的類庫，一般情況下這個就是程序中默認的類加載器。

  • 自定義類加載器

    • 由用戶自己實現。

1. 如果不想打破雙親委派模型，那麼只需要重寫findClass方法即可。
2. 否則就重寫整個loadClass方法。

• 雙親委派模型

  • 雙親委派模型要求除了頂層的啟動類加載器外，其餘的類加載器都應該有自己的父類加載器。父子不會以繼承的關係類實現，而是都是使用組合關係來服用父加載器的代碼。
    在java.lang.ClassLoader的loadClass()方法中實現。

  • 工作過程

    • 一個類加載器首先將類加載請求轉發到父類加載器，只有當父類加載器無法完成（它的搜索範圍中沒有找到所需要的類）時才嘗試自己加載

  • 好處

    • Java類隨着它的類加載器一起具備了一種帶有優先級的層次關係，從而使得基礎類庫得到同意。

四、內存分配與回收策略

Minor GC 和 Full GC

• Minor GC

  • 發生在新生代的垃圾收集動作，因為新生代對象存活時間很短，因此Minor GC會頻繁執行，執行速度快。

  • 時機

    • Eden不足

• Full GC

  • 發生在老年區的GC，出現Full GC時往往伴隨着Minor GC，比Minor GC慢10倍以上。

  • 時機

    • 1. 調用System.gc()
      • 只是建議虛擬機執行Full GC，但是虛擬機不一定真正去執行。
        不建議使用這種方式，而是讓虛擬機管理內存。
    • 1. 老年代空間不足
      • 常見場景就是大對象和長期存活對象進入老年代。
        盡量避免創建過大的對象以及數組，調大新生代大小，讓對象盡量咋新生代中被回收，不進入老年代。
    • 1. JDK1.7 之前方法區空間不足
      • 當系統中要加載的類、反射的類和常量較多時，永久代可能會被佔滿，在未配置CMS GC的情況下也會執行Full GC，如果空間仍然不夠則會拋出OOM異常。
        可採用增大方法區空間或轉為使用CMS GC。
    • 1. 空間分配擔保失敗
      • 發生Minor GC時分配擔保的兩個判斷失敗
    • 1. Concurrent Mode Failure
      • CMS GC 併發清理階段用戶線程還在執行，不斷有新的浮動垃圾產生，當預留空間不足時報Concurrent Mode Failure錯誤並觸發Full GC。

內存分配策略

• 1. 對象優先在Eden分配
  • 大多數情況下，對象在新生代Eden上分配，當Eden空間不夠時，發起Minor GC，當另外一個Survivor空間不足時則將存活對象通過分配擔保機制提前轉移到老年代。
• 1. 大對象直接進入老年代
  • 配置參數-XX:PretenureSizeThreshold，大於此值得對象直接在老年代分配，避免在Eden和Survivor之間的大量內存複製。
• 1. 長期存活對象進入老年代
  • 虛擬機為每個對象定義了一個Age計數器，對象在Eden出生並經過Minor GC存活轉移到另一個Survivor空間中時Age++，增加到默認16則轉移到老年代。
• 1. 動態對象年齡綁定
  • 虛擬機並不是永遠要求對象的年齡必須到達MaxTenuringThreshold才能晉陞老年代，如果在Survivor中相同年齡所有對象大小總和大於Survivor空間的一半，則年齡大於或等於該年齡的對象直接進入老年代。
• 1. 空間分配擔保
  • 在發生Minor GC之前，虛擬機先檢查老年代最大可用的連續空間是否大於新生代的所有對象，如果條件成立，那麼Minor GC可以認為是安全的。
    可以通過HandlePromotionFailure參數設置允許冒險，此時虛擬機將與歷代晉陞到老年區對象的平均大小比較，仍小於則要進行一次Full GC。
    在JDK1.6.24之後HandlePromotionFailure已無作用，即虛擬機默認為true。

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

【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

目錄

前言
本文主要多方面講解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文章

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

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

【其他文章推薦】

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

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

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

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

編者注：Netty是Java領域有名的開源網絡庫，特點是高性能和高擴展性，因此很多流行的框架都是基於它來構建的，比如我們熟知的Dubbo、Rocketmq、Hadoop等。本文就netty線程模型展開分析討論下 : )

IO模型

• BIO：同步阻塞IO模型；
• NIO：基於IO多路復用技術的“非阻塞同步”IO模型。簡單來說，內核將可讀可寫事件通知應用，由應用主動發起讀寫操作；
• AIO：非阻塞異步IO模型。簡單來說，內核將讀完成事件通知應用，讀操作由內核完成，應用只需操作數據即可；應用做異步寫操作時立即返回，內核會進行寫操作排隊並執行寫操作。

NIO和AIO不同之處在於應用是否進行真正的讀寫操作。

reactor和proactor模型

• reactor：基於NIO技術，可讀可寫時通知應用；
• proactor：基於AIO技術，讀完成時通知應用，寫操作應用通知內核。

netty線程模型

netty的線程模型是基於Reactor模型的。

netty單線程模型

Reactor 單線程模型，是指所有的 I/O 操作都在同一個 NIO 線程上面完成的，此時NIO線程職責包括：接收新建連接請求、讀寫操作等。

在一些小容量應用場景下，可以使用單線程模型（注意，Redis的請求處理也是單線程模型，為什麼Redis的性能會如此之高呢？因為Redis的讀寫操作基本都是內存操作，並且Redis協議比較簡潔，序列化/反序列化耗費性能更低）。但是對於高負載、大併發的應用場景卻不合適，主要原因如下：

• 一個NIO線程同時處理成百上千的連接，性能上無法支撐，即便NIO線程的CPU負荷達到100%，也無法滿足海量消息的編碼、解碼、讀取和發送。
• 當NIO線程負載過重之後，處理速度將變慢，這會導致大量客戶端連接超時，超時之後往往會進行重發，這更加重了NIO線程的負載，最終會導致大量消息積壓和處理超時，成為系統的性能瓶頸。
• 可靠性問題：一旦NIO線程意外跑飛，或者進入死循環，會導致整個系統通信模塊不可用，不能接收和處理外部消息，造成節點故障。

Reactor多線程模型

Rector 多線程模型與單線程模型最大的區別就是有一組 NIO 線程來處理連接讀寫操作，一個NIO線程處理Accept。一個NIO線程可以處理多個連接事件，一個連接的事件只能屬於一個NIO線程。

在絕大多數場景下，Reactor 多線程模型可以滿足性能需求。但是，在個別特殊場景中，一個 NIO 線程負責監聽和處理所有的客戶端連接可能會存在性能問題。例如併發百萬客戶端連接，或者服務端需要對客戶端握手進行安全認證，但是認證本身非常損耗性能。在這類場景下，單獨一個 Acceptor 線程可能會存在性能不足的問題，為了解決性能問題，產生了第三種 Reactor 線程模型——主從Reactor 多線程模型。

Reactor主從多線程模型

主從 Reactor 線程模型的特點是：服務端用於接收客戶端連接的不再是一個單獨的 NIO 線程，而是一個獨立的 NIO 線程池。Acceptor 接收到客戶端 TCP連接請求並處理完成后（可能包含接入認證等），將新創建的 SocketChannel注 冊 到 I/O 線 程 池（sub reactor 線 程 池）的某個I/O線程上， 由它負責SocketChannel 的讀寫和編解碼工作。Acceptor 線程池僅僅用於客戶端的登錄、握手和安全認證，一旦鏈路建立成功，就將鏈路註冊到後端 subReactor 線程池的 I/O 線程上，由 I/O 線程負責後續的 I/O 操作。

netty線程模型思考

netty 的線程模型並不是一成不變的，它實際取決於用戶的啟動參數配置。通過設置不同的啟動參數，Netty 可以同時支持 Reactor 單線程模型、多線程模型。

為了盡可能地提升性能，Netty 在很多地方進行了無鎖化的設計，例如在 I/O 線程內部進行串行操作，避免多線程競爭導致的性能下降問題。表面上看，串行化設計似乎 CPU 利用率不高，併發程度不夠。但是，通過調整 NIO 線程池的線程參數，可以同時啟動多個串行化的線程并行運行，這種局部無鎖化的串行線程設計相比一個隊列多個工作線程的模型性能更優。（小夥伴們後續多線程併發流程可參考該類實現方案）

Netty 的 NioEventLoop 讀取到消息之後，直接調用 ChannelPipeline 的fireChannelRead (Object msg)。 只要用戶不主動切換線程， 一直都是由NioEventLoop 調用用戶的 ChannelHandler，期間不進行線程切換。這種串行化處理方式避免了多線程操作導致的鎖的競爭，從性能角度看是最優的。

Netty擁有兩個NIO線程池，分別是bossGroup和workerGroup，前者處理新建連接請求，然後將新建立的連接輪詢交給workerGroup中的其中一個NioEventLoop來處理，後續該連接上的讀寫操作都是由同一個NioEventLoop來處理。注意，雖然bossGroup也能指定多個NioEventLoop（一個NioEventLoop對應一個線程），但是默認情況下只會有一個線程，因為一般情況下應用程序只會使用一個對外監聽端口。

這裏試想一下，難道不能使用多線程來監聽同一個對外端口么，即多線程epoll_wait到同一個epoll實例上？

epoll相關的主要兩個方法是epoll_wait和epoll_ctl，多線程同時操作同一個epoll實例，那麼首先需要確認epoll相關方法是否線程安全：簡單來說，epoll是通過鎖來保證線程安全的, epoll中粒度最小的自旋鎖ep->lock(spinlock)用來保護就緒的隊列, 互斥鎖ep->mtx用來保護epoll的重要數據結構紅黑樹。

看到這裏，可能有的小夥伴想到了Nginx多進程針對監聽端口的處理策略，Nginx是通過accept_mutex機制來保證的。accept_mutex是nginx的(新建連接)負載均衡鎖，讓多個worker進程輪流處理與client的新連接。當某個worker進程的連接數達到worker_connections配置（單個worker進程的最大處理連接數）的最大連接數的7/8時，會大大減小獲取該worker獲取accept鎖的概率，以此實現各worker進程間的連接數的負載均衡。accept鎖默認打開，關閉它時nginx處理新建連接耗時會更短，但是worker進程之間可能連接不均衡，並且存在“驚群”問題。只有在使能accept_mutex並且當前系統不支持原子鎖時，才會用文件實現accept鎖。注意，accept_mutex加鎖失敗時不會阻塞當前線程，類似tryLock。

現代linux中，多個socker同時監聽同一個端口也是可行的，nginx 1.9.1也支持這一行為。linux 3.9以上內核支持SO_REUSEPORT選項，允許多個socker bind/listen在同一端口上。這樣，多個進程可以各自申請socker監聽同一端口，當連接事件來臨時，內核做負載均衡，喚醒監聽的其中一個進程來處理，reuseport機制有效的解決了epoll驚群問題。

再回到剛才提出的問題，java中多線程來監聽同一個對外端口，epoll方法是線程安全的，這樣就可以使用使用多線程監聽epoll_wait了么，當然是不建議這樣乾的，除了epoll的驚群問題之外，還有一個就是，一般開發中我們使用epoll設置的是LT模式（水平觸發方式，與之相對的是ET默認，前者只要連接事件未被處理就會在epoll_wait時始終觸發，後者只會在真正有事件來時在epoll_wait觸發一次），這樣的話，多線程epoll_wait時就會導致第一個線程epoll_wait之後還未處理完畢已發生的事件時，第二個線程也會epoll_wait返回，顯然這不是我們想要的，關於java nio的測試demo如下：

public class NioDemo {
    private static AtomicBoolean flag = new AtomicBoolean(true);
    public static void main(String[] args) throws Exception {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.socket().bind(new InetSocketAddress(8080));
        // non-block io
        serverChannel.configureBlocking(false);
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 多線程執行
        Runnable task = () -> {
            try {
                while (true) {
                    if (selector.select(0) == 0) {
                        System.out.println("selector.select loop... " + Thread.currentThread().getName());
                        Thread.sleep(1);
                        continue;
                    }

                    if (flag.compareAndSet(true, false)) {
                        System.out.println(Thread.currentThread().getName() + " over");
                        return;
                    }

                    Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                    while (iter.hasNext()) {
                        SelectionKey key = iter.next();

                        // accept event
                        if (key.isAcceptable()) {
                            handlerAccept(selector, key);
                        }

                        // socket event
                        if (key.isReadable()) {
                            handlerRead(key);
                        }

                        /**
                         * Selector不會自己從已選擇鍵集中移除SelectionKey實例，必須在處理完通道時手動移除。
                         * 下次該通道變成就緒時，Selector會再次將其放入已選擇鍵集中。
                         */
                        iter.remove();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        };

        List<Thread> threadList = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            Thread thread = new Thread(task);
            threadList.add(thread);
            thread.start();
        }
        for (Thread thread : threadList) {
            thread.join();
        }
        System.out.println("main end");
    }

    static void handlerAccept(Selector selector, SelectionKey key) throws Exception {
        System.out.println("coming a new client... " + Thread.currentThread().getName());
        Thread.sleep(10000);
        SocketChannel channel = ((ServerSocketChannel) key.channel()).accept();
        channel.configureBlocking(false);
        channel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
    }

    static void handlerRead(SelectionKey key) throws Exception {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear();

        int num = channel.read(buffer);
        if (num <= 0) {
            // error or fin
            System.out.println("close " + channel.getRemoteAddress());
            channel.close();
        } else {
            buffer.flip();
            String recv = Charset.forName("UTF-8").newDecoder().decode(buffer).toString();
            System.out.println("recv: " + recv);

            buffer = ByteBuffer.wrap(("server: " + recv).getBytes());
            channel.write(buffer);
        }
    }
}

netty線程模型實踐

(1) 時間可控的簡單業務直接在 I/O 線程上處理

時間可控的簡單業務直接在 I/O 線程上處理，如果業務非常簡單，執行時間非常短，不需要與外部網絡交互、訪問數據庫和磁盤，不需要等待其它資源，則建議直接在業務 ChannelHandler 中執行，不需要再啟業務的線程或者線程池。避免線程上下文切換，也不存在線程併發問題。

(2) 複雜和時間不可控業務建議投遞到後端業務線程池統一處理

複雜度較高或者時間不可控業務建議投遞到後端業務線程池統一處理，對於此類業務，不建議直接在業務 ChannelHandler 中啟動線程或者線程池處理，建議將不同的業務統一封裝成 Task，統一投遞到後端的業務線程池中進行處理。過多的業務ChannelHandler 會帶來開發效率和可維護性問題，不要把 Netty 當作業務容器，對於大多數複雜的業務產品，仍然需要集成或者開發自己的業務容器，做好和Netty 的架構分層。

(3) 業務線程避免直接操作 ChannelHandler

業務線程避免直接操作 ChannelHandler，對於 ChannelHandler，IO 線程和業務線程都可能會操作，因為業務通常是多線程模型，這樣就會存在多線程操作ChannelHandler。為了盡量避免多線程併發問題，建議按照 Netty 自身的做法，通過將操作封裝成獨立的 Task 由 NioEventLoop 統一執行，而不是業務線程直接操作，相關代碼如下所示：

如果你確認併發訪問的數據或者併發操作是安全的，則無需多此一舉，這個需要根據具體的業務場景進行判斷，靈活處理。

推薦閱讀

歡迎小夥伴關注【TopCoder】閱讀更多精彩好文。

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

【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享