華為二面！！！面試官直接問我Java中到底什么是NIO？這不是直接送分題？？？

什么是NIO
緩沖區(Buffer)
- 緩沖區型別
- 獲取緩沖區
- 核心屬性
- 核心方法
非直接緩沖區和直接緩沖區
- 非直接緩沖區
- 直接緩沖區
通道(Channel)
- Java Channel
- - 獲得通道的方法
  - - 物件呼叫getChannel() 方法
    - getChannel()+非直接緩沖區
    - open()+直接緩沖區
    - 通道間直接傳輸
    - 直接緩沖區VS非直接緩沖區
- 分散和聚集
非阻塞式網路通信
- 概念
- 阻塞式網路通信
- 非阻塞式網路通信
- - 選擇器

什么是NIO

Java NIO（New IO）是從Java 1.4版本開始引入的一個新的IO API，可以替代標準的Java IO API，NIO與原來的IO有同樣的作用和目的，但是使用的方式完全不同，NIO支持面向緩沖區的、基于通道的IO操作，NIO將以更加高效的方式進行檔案的讀寫操作，

IO	NIO
面向流(Stream Oriented)	面向緩沖區(Buffer Oriented)
阻塞IO(Blocking IO)	非阻塞IO(NonBlocking IO)
	選擇器(Selectors)

底層原理可見：作業系統-檔案IO

緩沖區(Buffer)

緩沖區型別

Buffer 就像一個陣列，可以保存多個相同型別的資料，根據資料型別不同(boolean 除外) ，有以下Buffer 常用子類

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

各種型別的緩沖區中，都有一個對應型別的陣列，如

ByteBuffer

final byte[] hb;                  // Non-null only for heap buffersCopy

IntBuffer

final int[] hb;                  // Non-null only for heap buffers

獲取緩沖區

通過allocate方法可以獲取一個對應緩沖區的物件，它是緩沖區類的一個靜態方法

例

// 獲取一個容量大小為1024位元組的位元組緩沖區
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

核心屬性

緩沖區的父類Buffer中有幾個核心屬性，如下

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;Copy

capacity：緩沖區的容量，通過建構式賦予，一旦設定，無法更改
limit：緩沖區的界限，位于limit 后的資料不可讀寫，緩沖區的限制不能為負，并且不能大于其容量
position：下一個讀寫位置的索引（類似PC），緩沖區的位置不能為負，并且不能大于limit
mark：記錄當前position的值，position被改變后，可以通過呼叫reset() 方法恢復到mark的位置，

以上四個屬性必須滿足以下要求

mark <= position <= limit <= capacity

核心方法

put()方法

put()方法可以將一個資料放入到緩沖區中，
進行該操作后，postition的值會+1，指向下一個可以放入的位置，capacity = limit ，為緩沖區容量的值，

flip()方法

flip()方法會切換對緩沖區的操作模式，由寫->讀 / 讀->寫
進行該操作后
- 如果是寫模式->讀模式，position = 0 ， limit 指向最后一個元素的下一個位置，capacity不變
- 如果是讀->寫，則恢復為put()方法中的值

get()方法

get()方法會讀取緩沖區中的一個值
進行該操作后，position會+1，如果超過了limit則會拋出例外

rewind()方法

該方法只能在讀模式下使用
rewind()方法后，會恢復position、limit和capacity的值，變為進行get()前的值

clean()方法

clean()方法會將緩沖區中的各個屬性恢復為最初的狀態，position = 0, capacity = limit
此時緩沖區的資料依然存在，處于“被遺忘”狀態，下次進行寫操作時會覆寫這些資料

mark()和reset()方法

mark()方法會將postion的值保存到mark屬性中
reset()方法會將position的值改為mark中保存的值

使用展示

import java.nio.ByteBuffer;

public class demo1 {
    public static void main(String[] args) {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        System.out.println("放入前引數");
        System.out.println("position " + byteBuffer.position());
        System.out.println("limit " + byteBuffer.limit());
        System.out.println("capacity " + byteBuffer.capacity());
        System.out.println();

        System.out.println("------put()------");
        System.out.println("放入3個資料");
        byte bt = 1;
        byteBuffer.put(bt);
        byteBuffer.put(bt);
        byteBuffer.put(bt);

        System.out.println("放入后引數");
        System.out.println("position " + byteBuffer.position());
        System.out.println("limit " + byteBuffer.limit());
        System.out.println("capacity " + byteBuffer.capacity());
        System.out.println();

        System.out.println("------flip()-get()------");
        System.out.println("讀取一個資料");
        // 切換模式
        byteBuffer.flip();
        byteBuffer.get();

        System.out.println("讀取后引數");
        System.out.println("position " + byteBuffer.position());
        System.out.println("limit " + byteBuffer.limit());
        System.out.println("capacity " + byteBuffer.capacity());
        System.out.println();

        System.out.println("------rewind()------");
        byteBuffer.rewind();
        System.out.println("恢復后引數");
        System.out.println("position " + byteBuffer.position());
        System.out.println("limit " + byteBuffer.limit());
        System.out.println("capacity " + byteBuffer.capacity());
        System.out.println();

        System.out.println("------clear()------");
        // 清慷訓沖區，這里只是恢復了各個屬性的值，但是緩沖區里的資料依然存在
        // 但是下次寫入的時候會覆寫緩沖區中之前的資料
        byteBuffer.clear();
        System.out.println("清空后引數");
        System.out.println("position " + byteBuffer.position());
        System.out.println("limit " + byteBuffer.limit());
        System.out.println("capacity " + byteBuffer.capacity());
        System.out.println();
        System.out.println("清空后獲得資料");
        System.out.println(byteBuffer.get());

    }
}

放入前引數
position 0
limit 1024
capacity 1024

------put()------
放入3個資料
放入后引數
position 3
limit 1024
capacity 1024

------flip()-get()------
讀取一個資料
讀取后引數
position 1
limit 3
capacity 1024

------rewind()------
恢復后引數
position 0
limit 3
capacity 1024

------clear()------
清空后引數
position 0
limit 1024
capacity 1024

清空后獲得資料
1

Process finished with exit code 0

非直接緩沖區和直接緩沖區

非直接緩沖區

通過allocate()方法獲取的緩沖區都是非直接緩沖區，這些緩沖區是建立在JVM堆記憶體之中的，

public static ByteBuffer allocate(int capacity) {
   if (capacity < 0)
   throw new IllegalArgumentException();

   // 在堆記憶體中開辟空間
   return new HeapByteBuffer(capacity, capacity);
}

HeapByteBuffer(int cap, int lim) {        // package-private
   // new byte[cap] 創建陣列，在堆記憶體中開辟空間
   super(-1, 0, lim, cap, new byte[cap], 0);
   /*
   hb = new byte[cap];
   offset = 0;
   */
}

通過非直接緩沖區，想要將資料寫入到物理磁盤中，或者是從物理磁盤讀取資料，都需要經過JVM和作業系統，資料在兩個地址空間中傳輸時，會copy一份保存在對方的空間中，所以費直接緩沖區的讀取效率較低.，

直接緩沖區

只有ByteBuffer可以獲得直接緩沖區，通過allocateDirect()獲取的緩沖區為直接緩沖區，這些緩沖區是建立在物理記憶體之中的，

public static ByteBuffer allocateDirect(int capacity) {
   return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) {                   // package-private
   ...
   // 申請物理記憶體
   boolean pa = VM.isDirectMemoryPageAligned();
   ...
}

直接緩沖區通過在作業系統和JVM之間創建物理記憶體映射檔案加快緩沖區資料讀/寫入物理磁盤的速度，放到物理記憶體映射檔案中的資料就不歸應用程式控制了，作業系統會自動將物理記憶體映射檔案中的資料寫入到物理記憶體中，

通道(Channel)

Channel由java.nio.channels 包定義的，Channel 表示IO 源與目標打開的連接，Channel 類似于傳統的“流”，只不過Channel 本身不能直接訪問資料，Channel 只能與Buffer 進行互動 ，

應用程式進行讀寫操作呼叫函式時，底層呼叫的作業系統提供給用戶的讀寫API，呼叫這些API時會生成對應的指令，CPU則會執行這些指令，在計算機剛出現的那段時間，所有讀寫請求的指令都有CPU去執行，過多的讀寫請求會導致CPU無法去執行其他命令，從而CPU的利用率降低，

后來，DMA(Direct Memory Access，直接存盤器訪問)出現了，當IO請求傳到計算機底層時，DMA會向CPU請求，讓DMA去處理這些IO操作，從而可以讓CPU去執行其他指令，DMA處理IO操作時，會請求獲取總線的使用權，當IO請求過多時，會導致大量總線用于處理IO請求，從而降低效率 ，

于是便有了Channel(通道)，Channel相當于一個專門用于IO操作的獨立處理器，它具有獨立處理IO請求的能力，當有IO請求時，它會自行處理這些IO請求，

Java Channel

本地檔案IO
- FileChannel
網路IO
- SocketChanel、ServerSocketChannel：用于TCP傳輸
- DatagramChannel：用于UDP傳輸

獲得通道的方法

物件呼叫getChannel() 方法

獲取通道的一種方式是對支持通道的物件呼叫getChannel() 方法，支持通道的類如下：

FileInputStream
FileOutputStream
RandomAccessFile
DatagramSocket
Socket
ServerSocket

例子：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramSocket;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.channels.DatagramChannel;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;

public class demo2 {
    public static void main(String[] args) throws IOException {
        // 本地通道
        FileInputStream fileInputStream = new FileInputStream("zwt");
        FileChannel channel1 = fileInputStream.getChannel();

        FileOutputStream fileOutputStream = new FileOutputStream("zwt");
        FileChannel channel2 = fileOutputStream.getChannel();

        // 網路通道
        Socket socket = new Socket();
        SocketChannel channel3 = socket.getChannel();

        ServerSocket serverSocket = new ServerSocket();
        ServerSocketChannel channel4 = serverSocket.getChannel();

        DatagramSocket datagramSocket = new DatagramSocket();
        DatagramChannel channel5 = datagramSocket.getChannel();

        // 最后要關閉通道

        FileChannel open = FileChannel.open(Paths.get("zwt"));

        SocketChannel open1 = SocketChannel.open();

    }
}

getChannel()+非直接緩沖區

getChannel()獲得通道
allocate()獲得非直接緩沖區

通過非直接緩沖區讀寫資料，需要通過通道來傳輸緩沖區里的資料

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class demo4 {
    public static void main(String[] args) {
        FileInputStream is = null;
        FileOutputStream os = null;
        // 獲得通道
        FileChannel inChannel = null;
        FileChannel outChannel = null;

        // 利用 try-catch-finally 保證關閉
        try {
            is = new FileInputStream("");
            os = new FileOutputStream("");

            // 獲得通道
            inChannel = is.getChannel();
            outChannel = os.getChannel();

            // 獲得緩沖區，用于在通道中傳輸資料
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            // 回圈將位元組資料放入到buffer中，然后寫入磁盤中
            while (inChannel.read(byteBuffer) != -1) {
                // 切換模式
                byteBuffer.flip();
                outChannel.write(byteBuffer);
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inChannel != null) {
                try {
                    inChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outChannel != null) {
                try {
                    outChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

open()+直接緩沖區

通過open獲得通道
通過FileChannel.map()獲取直接緩沖區

使用直接緩沖區時，無需通過通道來傳輸資料，直接將資料放在緩沖區內即可

import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class demo5 {
   public static void main(String[] args) throws IOException {
       // 通過open()方法來獲得通道
       FileChannel inChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ);

       // outChannel需要為 READ WRITE CREATE模式
       // READ WRITE是因為后面獲取直接緩沖區時模式為READ_WRITE模式
       // CREATE是因為要創建新的檔案
       FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);

       // 獲得直接緩沖區
       MappedByteBuffer inMapBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
       MappedByteBuffer outMapBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

       // 位元組陣列
       byte[] bytes = new byte[inMapBuf.limit()];

       // 因為是直接緩沖區，可以直接將資料放入到記憶體映射檔案，無需通過通道傳輸
       inMapBuf.get(bytes);
       outMapBuf.put(bytes);

       // 關倍訓沖區，這里沒有用try-catch-finally
       inChannel.close();
       outChannel.close();
   }
}

通道間直接傳輸

public static void channelToChannel() throws IOException {
  long start = System.currentTimeMillis();
  // 通過open()方法來獲得通道
  FileChannel inChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ);

  // outChannel需要為 READ WRITE CREATE模式
  // READ WRITE是因為后面獲取直接緩沖區時模式為READ_WRITE模式
  // CREATE是因為要創建新的檔案
  FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);

  // 通道間直接傳輸
  inChannel.transferTo(0, inChannel.size(), outChannel);
  // 對應的還有transferFrom
  // outChannel.transferFrom(inChannel, 0, inChannel.size());

  inChannel.close();
  outChannel.close();
}

直接緩沖區VS非直接緩沖區

// getChannel() + 非直接緩沖區耗時
708
// open() + 直接緩沖區耗時
115
// channel transferTo channel耗時
47

直接緩沖區的讀寫速度雖然很快，但是會占用很多很多記憶體空間，如果檔案過大，會使得計算機運行速度變慢

分散和聚集

分散讀取

分散讀取（Scattering Reads）是指從Channel 中讀取的資料“分散”到多個Buffer 中，

注意：按斬訓沖區的順序，從Channel 中讀取的資料依次將 Buffer 填滿，

聚集寫入

聚集寫入（Gathering Writes）是指將多個Buffer 中的資料“聚集”到Channel，

按斬訓沖區的順序，寫入position 和limit 之間的資料到Channel，

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class demo6 {
    public static void main(String[] args) throws IOException {
        FileInputStream is = new FileInputStream("");
        FileOutputStream os = new FileOutputStream("");

        FileChannel inChannel = is.getChannel();
        FileChannel outChannel = os.getChannel();

        // 獲得多個緩沖區，并且放入到緩沖區陣列中
        ByteBuffer byteBuffer1 = ByteBuffer.allocate(50);
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        ByteBuffer[] byteBuffers = {byteBuffer1, byteBuffer2};

        // 分散讀取
        inChannel.read(byteBuffers);

        byteBuffer1.flip();
        byteBuffer2.flip();

        // 聚集寫入
        outChannel.write(byteBuffers);
    }
}

非阻塞式網路通信

概念

底層原理可見：作業系統-檔案IO

比喻：

舉個你去飯堂吃飯的例?，你好??戶程式，飯堂好?作業系統，

阻塞 I/O 好?，
你去飯堂吃飯，但是飯堂的菜還沒做好，然后你就?直在那?等啊等，

等了好??段時間終于等到飯堂阿姨把菜端了出來（資料準備的程序），

但是你還得繼續等阿姨把菜（內核空間）打到你的飯盒?（?戶空間），

經歷完這兩個程序，你才可以離開，

?阻塞 I/O 好?，
你去了飯堂，問阿姨菜做好了沒有，阿姨告訴你沒，

你就離開了，過??分鐘，你?來，

飯堂問阿姨，阿姨說做好了，于是阿姨幫你把菜打到你的飯盒?，這個程序你是得等待的，

基于?阻塞的 I/O 多路復?好?，
你去飯堂吃飯，發現有?排窗?，飯堂阿姨告訴你這些窗?都還沒做好菜，

等做好了再通知你，于是等啊等（ select 調?中），過了?會阿姨通知你菜做好了，

但是不知道哪個窗?的菜做好了，你??看吧，

于是你只能?個?個窗?去確認，后?發現 5 號窗?菜做好了，

于是你讓 5 號窗?的阿姨幫你打菜到飯盒?，這個打菜的程序你是要等待的，雖然時間不?，

打完菜后，你?然就可以離開了，

異步 I/O 好?，
你讓飯堂阿姨將菜做好并把菜打到飯盒?后，把飯盒送到你?前，整個程序你都不需要任何等待，

阻塞式網路通信

package NIOAndBIO;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class BIO {
    public static void main(String[] args) throws IOException {
        Thread thread1 = new Thread(() -> {
            try {
                server();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                client();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }

    public static void client() throws IOException {
        // 創建客戶端通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2022));

        // 讀取資訊 D:\\bizhi\\bizhi202008\\wallhaven-kwp2qq.jpg
        FileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.READ);

        // 創建緩沖區
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 寫入資料
        while (fileChannel.read(byteBuffer) != -1) {
            byteBuffer.flip();
            socketChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        fileChannel.close();
        socketChannel.close();
    }

    public static void server() throws IOException {
        // 創建服務端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        FileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        // 系結鏈接
        serverSocketChannel.bind(new InetSocketAddress(2022));

        // 獲取客戶端的通道
        SocketChannel socketChannel = serverSocketChannel.accept();

        // 創建緩沖區
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        while (socketChannel.read(byteBuffer) != -1) {
            byteBuffer.flip();
            fileChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        socketChannel.close();
        fileChannel.close();
        serverSocketChannel.close();
    }
}

非阻塞式網路通信

package NIOAndBIO;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;

public class NIO {
    public static void main(String[] args) {
        Thread thread1 = new Thread(()->{
            try {
                server();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(()->{
            try {
                client();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        thread2.start();
    }

    public static void client() throws IOException {
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2020));

        // 設定為非阻塞模式
        socketChannel.configureBlocking(false);

        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String str = scanner.next();
            byteBuffer.put(str.getBytes());
            byteBuffer.flip();
            socketChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        byteBuffer.clear();

        socketChannel.close();
    }

    public static void server() throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(2020));

        // 獲得選擇器
        Selector selector = Selector.open();

        // 將通道注冊到選擇器中，設定為接收操作
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 輪詢接受
        while (selector.select() > 0) {
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            // 獲得事件的key
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // 從選擇器中獲取通道
                    SocketChannel socketChannel = (SocketChannel) key.channel();

                    ByteBuffer byteBuffer = ByteBuffer.allocate(10);

                    while (socketChannel.read(byteBuffer) != -1) {
                        int len = byteBuffer.limit();
                        byteBuffer.flip();
                        System.out.println(new String(byteBuffer.array(), 0, len));
                        byteBuffer.clear();
                    }
                    socketChannel.close();
                }
                iterator.remove();
            }
        }
        serverSocketChannel.close();
    }
}

選擇器

選擇器（Selector）是SelectableChannle 物件的多路復用器，Selector 可以同時監控多個SelectableChannel 的IO 狀況，也就是說，利用Selector 可使一個單獨的執行緒管理多個Channel，Selector 是非阻塞IO 的核心 ，

選擇器的創建

// 創建一個選擇器
Selector selector = Selector.open();

系結選擇器

通過呼叫通道的register方法可以系結選擇器，register方法有兩個引數

Selector：即系結哪個選擇器
ops：監聽事件型別，ops有4個值可以選擇，為SelectionKey的靜態屬性

// 讓選擇器監聽一種狀態
myChannel.register(selector, SelectionKey.OP_READ);
// 讓選擇器監聽多種狀態
myChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_ACCEPT);

SelectionKey

表示SelectableChannel 和Selector 之間的注冊關系，每次向選擇器注冊通道時就會選擇一個事件(選擇鍵)，選擇鍵包含兩個表示為整數值的操作集，操作集的每一位都表示該鍵的通道所支持的一類可選擇操作，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/307234.html

標籤：java

上一篇：面試官問我List介面，我

下一篇：這篇博客和你嘮嘮 python 并發，滾雪球學python第四季，第16篇