目錄

前言
本文主要多方面講解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地圖已可更新顯示潭子電動車充電站設置地點!!

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

npm install 命令

首先總結下npm 安裝一個模塊包的常用命令。

/* 模塊依賴會寫入 dependencies 節點 */

npm install moduleName

npm install -save moduleName

npm install -S moduleName 

/* 模塊依賴會寫入 devDependencies 節點 */

npm install -save-dev moduleName

npm install -D moduleName

/* 全局安裝模塊包 */

npm install -g moduleName

/* 安裝特定版本的包 */

npm install 包名@版本號

/* 通過地址安裝git倉庫 */

npm install git+https://github.com/itwmike/axios.git

npm install git+ssh://git@github.com:itwmike/axios.git
 
/* 安裝特定分支或Tag的git倉庫 */

npm install git+https://github.com/itwmike/axios.git#tag

/* 通過用戶名安裝git倉庫 */ 

npm install github:帳號/倉庫名 # npm install github:itwmike/axios

npm install github:帳號/倉庫名

npm 依賴包版本號

npm 所有node包都使用語義化版本號，規則要求如下：  

• 每個版本號都形如1.2.3，由三個部分組成，依次叫做“主版本號(major)”、“次版本號(minor)”和“修訂號(patch)” 。

• 當新版本無法兼容基於前一版本的代碼時，則提高主版本號 。

• 當新版本新增了功能與特性，但仍兼容前一版本的代碼時，則提高次版本號 。

• 當新版本僅僅修正漏洞或者增強效率，仍然兼容前一版本代碼，則提高修訂號。

默認使用 npm install -save 下載的都是最新版本，同時會在package.json 文件中登記一個最優版本號，如下形式：

"dependencies": {
  "axios": "^0.19.0"
},

最優版本號前面會多出一個“標記”，這個標記有啥意義？它的寫法又有哪些？

npm install 都做了哪些事？

拿到一個node項目時首要做法是運行 npm install 命令，這個命令將 package.json 文件中的依賴包自動解析並安裝，這也是項目能夠本地運行的前置條件。那如此簡單的一條命令，npm 背後又做了哪些不為人知的事呢？

Number One

自 npm 5.0后，項目中如果沒有 package-lock.json 文件的時候，npm 會自動幫我們生成。該文件的主要作用是記錄依賴包之間的具體版本號，對包版本有一個鎖定的意義，項目開發中應該將此文件上傳到git等版本控制工具（博主為此經歷了血淋淋的慘痛教育）。

Number Two

檢測本地包是否已經下載。如果本地 node_modules 下已經存在和 package-lock.json 中版本一致的包，則不會重新下載。

Number Three

下載依賴節點中對應的模板包。下載規則是：如果 package-lock.json 文件存在，則按照該文件中記錄的版本號下載對應的模塊包；如果文件不存在或文件中沒有該包的記錄，此時會按照版本號的標記（上面已講）規範下載並同時更新到 package-lock.json。

了解了 package-lock.json 的作用后，筆者有個疑問：手動修改 package.json 中的包版本號后運行 npm install 命令會下載新包么？

帶着這個疑問，筆者做了實驗，得出如下結論：

• 如果新舊版本號差距較大，比如從 ^2.5.2 變為 2.6.0 ，那麼會下載最新包並且更新 package-lock.json 。

• 如果新舊版本號差距較小，比如從 ^2.5.2 變為 2.5.4，那麼不會更新。

總之是否更新要看特定情況，取決於 package.json中版本號的標記和 package-lock.json 是否一致。

cnpm install 探索

cnpm 是淘寶 npm 鏡像，在國內很受歡迎，雖然筆者並不喜歡使用。那 cnpm 和 npm 對包的管理是否一樣呢？

• cnpm install 並不會生成 package-lock.json

• cnpm install 並不受 package-lock.json 的約束，它會按照版本號標記規則下載依賴包

由此可見，我們在項目中使用 cnpm 的時候一定要慎重，因為很可能團隊成員每個人使用的依賴包版本都不相同，造成打包后的結果也不同。

如果團隊要使用 cnpm，請使用固定版本號的方式安裝依賴包如：cnpm install -E moduleName

本文轉載自：

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

【其他文章推薦】

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

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※南投搬家前需注意的眉眉角角，別等搬了再說!

11月14日小遊戲開發圈子，有一條重磅新聞：“微信小遊戲聯合遊戲引擎廠商，推出引擎插件功能，可為小遊戲提升0.5~2秒的啟動時間”。

引擎插件是個什麼東西？

昨天有不少人在問曉衡：“引擎插件到底是個什麼東西？”、“又要讓我學習新東西嗎？”、“引擎插件是怎麼加速的，不太明白？” …

曉衡也在第一時間，將文檔通讀了一遍，並用自己的小遊戲工程做了測試，對微信小遊戲引擎插件算是有了一個簡單的認識，看下圖：

普通模式，每一個使用遊戲引擎開發的小遊戲，都需要下載遊戲引擎代碼模塊。

引擎插件模式，僅第一個遊戲需要下載引擎代碼，其它使用同類引擎的遊戲，可共享之前 A 遊戲下載過的遊戲引擎代碼，從而加速遊戲的啟動時間。

從事小遊戲開發和運營的夥伴應該都很了解，H5、小遊戲注重啟動加載速度，它對新用戶的體驗和流失都至關重要。

啟動概況分析

估計有人會覺得引擎插件就加快了0.5~2秒有什麼用？眨個眼的時間而已。

其實對使用 Cocos Creator 開發的休閑類的小遊戲來說，目前的微信小遊戲啟動速度已經很不錯了，首包含引擎的話，iOS 在4 ~ 6秒啟動，Android 大多可以在6~8秒左右打開首屏，並不像微信吹噓的1秒啟動，估計只有 引擎和資源全放子包的遊戲可以做到！

下面我將自己個人開發的一款微信小遊戲，在微信公測的前後两天做了一個數據統計，想窺視一下啟動性能對留存的影響，下圖是曉衡的遊戲在8月7日 ~ 8月9日時的活躍情況：

遊戲是在8月7日的晚上10:00點打開的微信公測，微信平台在24小時內持續導入5184的用戶，當天遊戲啟動8121次。不過圖片上的數據比較尷尬，公測一過就沒幾個玩家了，但它不是我們要講的重點，我們是用這個時間節點、用戶數量，來看微信小遊戲的啟動性能表現。

iOS啟動概況

Android啟動概況

從圖中看，8月7日這天 iOS 的總啟動時間比 Android 快 3.88 秒，Android 的用戶流失比 iOS 要多 12.55%，這裏重點也不是說 iOS 和 Android 系統那個好，而是看遊戲的啟動時間對首屏打開留存的影響。

這是另一個朋友的遊戲《周車勞盾》在9月14日微信公測4800+用戶，遊戲啟動7000+次，下面是它在9月13~9月15日的啟動概況：

《周車勞盾》的 iOS 首屏打開留存率由於用戶數太少，不太好與 Android 對比，並且朋友說當時遊戲沒有做分包優化。在9月14日公測當天，由於新用戶多，iOS、Android 的啟動速度都不快，在 10 秒左右。從中也可以看出微信小遊戲用戶，以及微信導量用戶，以 Android 屬性為主。

啟動流失分析

下圖是曉衡的遊戲在8月8日公測時的 Android 手機用戶流失分佈情況，統計一共有 893 名流失用戶：

從前面的啟動概況看到，小遊戲啟動進入首屏是在8.38s，我們以9秒為分界線，將上圖分成左右兩部分：

• 右邊標註綠色線框，是已經進入遊戲后流失的人數，這部分的優化需要美術和策劃同學的幫助。
• 左邊紅色線框中的用戶，是在遊戲啟動過程中流失掉的共計679人佔76%，而且前4秒流失的最多共543占 60%，如果不計算已經打開首屏的更是高達80%，因此前幾秒它才是我們關心的重點。

曉衡根據平常使用微信的習慣，模擬分析一下前8秒的用戶是大概會是什麼情況走失的，需要注意的一個前題是，這些用戶都是微信導量進入的，絕大多是手滑不小心點到廣告，並不是目標用戶。

• 第1秒：1秒流失用戶，手滑的機率最大，似乎經過專業訓練，眼、腦、手的速度都非常的快，遊戲是什麼都沒看清就閃人了；
• 第2秒：2秒流失用戶，與1秒戶大概差不多，只是動作稍慢而已，此時遊戲圖標已經進入視覺系統，但估計比較模糊，瞬間閃人；
• 第3秒：3秒流失用戶，不僅遊戲圖標已經從視覺系統進入大腦，遊戲名字估計也是能看清楚，但是沒有任何感覺，同樣是條件反射，快速點擊關閉；
• 第4秒：4秒流失用戶，已經是把遊戲圖標、名字已經完全進入大腦神經迴路，給他反饋的信號是沒有愛，甚至是反感，迅速閃人了。第4秒很關鍵，因為用戶已經有了思考！
• 第5~6秒：5~6秒流失用戶，認真看完遊戲圖標、名字，以及加載進度，經過大腦綜合反饋，這個遊戲不值得等待，88了！
• 第7~8秒：7~8秒流失用戶，估計是盯到了遊戲的加載進度，在100%或某個数字上停止下一瞬間，實在是不耐煩了，什麼個鬼遊戲，半天進不去，走了！

以上分析是曉衡的個人YY，僅供參考，這裏要說的是前 3 秒流失的用戶大多是條件反射，很難轉化。當用戶將遊戲圖標、遊戲名稱看清了后，大腦產生了思考，再離開的這對我們來說還有機會爭取，讓他們早點看到遊戲首屏，已經花了這5、6秒了，體驗一下再走！

提升遊戲0.5 ~ 2秒的啟動速度是非常具有價值的，而且小遊戲絕大多數又是 Android 用戶，特別是對需要買量的遊戲來說，時間就是金錢，毫秒必爭。

引擎插件帶來的好處

下面我們再來看看，引擎插件具體在那些場景下會帶來比較明顯的性能提供，盡可能充分利用這個機制呢？

微信公測

對於個人開發者，使用微信公測功能免費送5000流量，一定要利用好這個機會。將首包資源做到盡量小巧，引擎裁剪、圖片壓縮一定要做足，同時盡量選擇使用量較多的引擎版本號（目前曉衡了解到的，使用較多 Cocos Creator 引擎版本號分佈在：2.0.8 ~ 2.0.10、2.1.3、2.2.0，不過還是要以微信或 Cocos 官方統計為準），這樣容易蹭上已經下載過的遊戲引擎，這對大多數遊戲來說都是適用的。

中重度遊戲

中重度遊戲，通常會依賴較多的引擎模塊，比如 RPG 遊戲中的：地圖、角色動畫，會使用TileMap、Spine、DragonBones、Animation 等模塊，還有一些遊戲會使用到物理引擎模塊、碰撞模塊等，完整引擎模塊高達 1.6M。

隨着微信引擎插件的廣泛普及，以後構建遊戲完全時可以將引擎裁剪到最精簡狀態，大概在550K左右。甚至可以想像到，以後小遊戲平台完全不用上傳引擎代碼，構建時只用配置上使用的什麼引擎，引擎版本號即可。

中重度遊戲利用引擎插件同樣可以快速進入首屏，首包僅保留炫麗的動效和初始界面，用分治的方式動態下載遊戲當前必要的內容，儘快讓用戶參与到遊戲中去。還有隨着 5G 的到來，中重度遊戲的遊戲資源下載劣勢也會得到改善，對小遊戲更是一件好事。

遊戲矩陣

單款小遊戲一般是很難有收益的，甚至是虧本買賣。微信平台，一個小遊戲可以支持10個遊戲的跳轉，目前絕大多數遊戲商廠，都會在小遊戲中集成其它遊戲的入口加大流量，優質的遊戲還會出售遊戲跳轉坑位，有的還價格不菲。個人開發者也意識到了遊戲間跳轉帶來的爆光機會，不少開發者會在微信公眾時，組織邀請好友建立鏈接。

如果是自家開發的休閑小遊戲，利用引擎插件的啟動增速，再配合上自定義的啟動背景（頭條支持），讓玩家感受不出是在不同遊戲中切換，在矩陣中瞬間穿梭，這也將極大增加遊戲的曝光率，降低流失。

小結

劉潤老師說的好：“一切的商業價值，要看是否讓用戶獲益”。

微信引擎插件不僅讓普通用戶能獲得更好的遊戲體驗，也能讓遊戲開發商能中從獲益。點開即玩的小遊戲，縮短了遊戲產品呈現在用戶手中的時間，極大優化了產品的傳遞價值。

曉衡是一個搬運工，傳遞有價值的遊戲開發技術，如果覺得本文對你有用，感謝來看個再看或傳遞給朋友。感謝您的閱讀，願我們在前進的道路上“砥礪前行，共同成長！”

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

【其他文章推薦】

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!