Java進階（五）Java I/O模型從BIO到NIO和Reactor模式

来源:http://www.cnblogs.com/jasongj/archive/2016/08/23/5797863.html
-Advertisement-
Play Games

本文介紹了Java中的四種I/O模型，同步阻塞，同步非阻塞，多路復用，非同步阻塞。同時將NIO和BIO進行了對比，並詳細分析了基於NIO的Reactor模式，包括經典單線程模型以及多線程模式和多Reactor模式。 ...


原創文章，同步發自作者個人博客，http://www.jasongj.com/java/nio_reactor/

Java I/O模型

同步 vs. 非同步

同步I/O　每個請求必須逐個地被處理，一個請求的處理會導致整個流程的暫時等待，這些事件無法併發地執行。用戶線程發起I/O請求後需要等待或者輪詢內核I/O操作完成後才能繼續執行。

非同步I/O　多個請求可以併發地執行，一個請求或者任務的執行不會導致整個流程的暫時等待。用戶線程發起I/O請求後仍然繼續執行，當內核I/O操作完成後會通知用戶線程，或者調用用戶線程註冊的回調函數。

阻塞 vs. 非阻塞

阻塞　某個請求發出後，由於該請求操作需要的條件不滿足，請求操作一直阻塞，不會返回，直到條件滿足。

非阻塞　請求發出後，若該請求需要的條件不滿足，則立即返回一個標誌信息告知條件不滿足，而不會一直等待。一般需要通過迴圈判斷請求條件是否滿足來獲取請求結果。

需要註意的是，阻塞並不等價於同步，而非阻塞並非等價於非同步。事實上這兩組概念描述的是I/O模型中的兩個不同維度。

同步和非同步著重點在於多個任務執行過程中，後發起的任務是否必須等先發起的任務完成之後再進行。而不管先發起的任務請求是阻塞等待完成，還是立即返回通過迴圈等待請求成功。

而阻塞和非阻塞重點在於請求的方法是否立即返回（或者說是否在條件不滿足時被阻塞）。

Unix下五種I/O模型

Unix 下共有五種 I/O 模型：

  • 阻塞 I/O
  • 非阻塞 I/O
  • I/O 多路復用（select和poll）
  • 信號驅動 I/O（SIGIO）
  • 非同步 I/O（Posix.1的aio_系列函數）

阻塞I/O

如上文所述，阻塞I/O下請求無法立即完成則保持阻塞。阻塞I/O分為如下兩個階段。

  • 階段1：等待數據就緒。網路 I/O 的情況就是等待遠端數據陸續抵達；磁碟I/O的情況就是等待磁碟數據從磁碟上讀取到內核態記憶體中。
  • 階段2：數據拷貝。出於系統安全，用戶態的程式沒有許可權直接讀取內核態記憶體，因此內核負責把內核態記憶體中的數據拷貝一份到用戶態記憶體中。

非阻塞I/O

非阻塞I/O請求包含如下三個階段

  • socket設置為 NONBLOCK（非阻塞）就是告訴內核，當所請求的I/O操作無法完成時，不要將線程睡眠，而是返回一個錯誤碼(EWOULDBLOCK) ，這樣請求就不會阻塞。
  • I/O操作函數將不斷的測試數據是否已經準備好，如果沒有準備好，繼續測試，直到數據準備好為止。整個I/O 請求的過程中，雖然用戶線程每次發起I/O請求後可以立即返回，但是為了等到數據，仍需要不斷地輪詢、重覆請求，消耗了大量的 CPU 的資源。
  • 數據準備好了，從內核拷貝到用戶空間。

一般很少直接使用這種模型，而是在其他I/O模型中使用非阻塞I/O 這一特性。這種方式對單個I/O 請求意義不大，但給I/O多路復用提供了條件。

I/O多路復用（非同步阻塞 I/O）

I/O多路復用會用到select或者poll函數，這兩個函數也會使線程阻塞，但是和阻塞I/O所不同的是，這兩個函數可以同時阻塞多個I/O操作。而且可以同時對多個讀操作，多個寫操作的I/O函數進行檢測，直到有數據可讀或可寫時，才真正調用I/O操作函數。

從流程上來看，使用select函數進行I/O請求和同步阻塞模型沒有太大的區別，甚至還多了添加監視Channel，以及調用select函數的額外操作，增加了額外工作。但是，使用 select以後最大的優勢是用戶可以在一個線程內同時處理多個Channel的I/O請求。用戶可以註冊多個Channel，然後不斷地調用select讀取被激活的Channel，即可達到在同一個線程內同時處理多個I/O請求的目的。而在同步阻塞模型中，必須通過多線程的方式才能達到這個目的。

調用select/poll該方法由一個用戶態線程負責輪詢多個Channel，直到某個階段1的數據就緒，再通知實際的用戶線程執行階段2的拷貝。 通過一個專職的用戶態線程執行非阻塞I/O輪詢，模擬實現了階段一的非同步化。

信號驅動I/O（SIGIO）

首先我們允許socket進行信號驅動I/O，並安裝一個信號處理函數，線程繼續運行並不阻塞。當數據準備好時，線程會收到一個SIGIO 信號，可以在信號處理函數中調用I/O操作函數處理數據。

非同步I/O

調用aio_read 函數，告訴內核描述字，緩衝區指針，緩衝區大小，文件偏移以及通知的方式，然後立即返回。當內核將數據拷貝到緩衝區後，再通知應用程式。所以非同步I/O模式下，階段1和階段2全部由內核完成，完成不需要用戶線程的參與。

幾種I/O模型對比

除非同步I/O外，其它四種模型的階段2基本相同，都是從內核態拷貝數據到用戶態。區別在於階段1不同。前四種都屬於同步I/O。

Java中四種I/O模型

上一章所述Unix中的五種I/O模型，除信號驅動I/O外，Java對其它四種I/O模型都有所支持。其中Java最早提供的blocking I/O即是阻塞I/O，而NIO即是非阻塞I/O，同時通過NIO實現的Reactor模式即是I/O復用模型的實現，通過AIO實現的Proactor模式即是非同步I/O模型的實現。

從IO到NIO

面向流 vs. 面向緩衝

Java IO是面向流的，每次從流（InputStream/OutputStream）中讀一個或多個位元組，直到讀取完所有位元組，它們沒有被緩存在任何地方。另外，它不能前後移動流中的數據，如需前後移動處理，需要先將其緩存至一個緩衝區。

Java NIO面向緩衝，數據會被讀取到一個緩衝區，需要時可以在緩衝區中前後移動處理，這增加了處理過程的靈活性。但與此同時在處理緩衝區前需要檢查該緩衝區中是否包含有所需要處理的數據，並需要確保更多數據讀入緩衝區時，不會覆蓋緩衝區內尚未處理的數據。

阻塞 vs. 非阻塞

Java IO的各種流是阻塞的。當某個線程調用read()或write()方法時，該線程被阻塞，直到有數據被讀取到或者數據完全寫入。阻塞期間該線程無法處理任何其它事情。

Java NIO為非阻塞模式。讀寫請求並不會阻塞當前線程，在數據可讀/寫前當前線程可以繼續做其它事情，所以一個單獨的線程可以管理多個輸入和輸出通道。

選擇器（Selector）

Java NIO的選擇器允許一個單獨的線程同時監視多個通道，可以註冊多個通道到同一個選擇器上，然後使用一個單獨的線程來“選擇”已經就緒的通道。這種“選擇”機製為一個單獨線程管理多個通道提供了可能。

零拷貝

Java NIO中提供的FileChannel擁有transferTo和transferFrom兩個方法，可直接把FileChannel中的數據拷貝到另外一個Channel，或者直接把另外一個Channel中的數據拷貝到FileChannel。該介面常被用於高效的網路/文件者數據傳輸和大文件拷貝。在操作系統支持的情況下，通過該方法傳輸數據並不需要將源數據從內核態拷貝到用戶態，再從用戶態拷貝到目標通道的內核態，同時也避免了兩次用戶態和內核態間的上下文切換，也即使用了“零拷貝”，所以其性能一般高於Java IO中提供的方法。

使用FileChannel的零拷貝將本地文件內容傳輸到網路的示例代碼如下所示。

public class NIOClient {

  public static void main(String[] args) throws IOException, InterruptedException {
    SocketChannel socketChannel = SocketChannel.open();
    InetSocketAddress address = new InetSocketAddress(1234);
    socketChannel.connect(address);

    RandomAccessFile file = new RandomAccessFile(
        NIOClient.class.getClassLoader().getResource("test.txt").getFile(), "rw");
    FileChannel channel = file.getChannel();
    channel.transferTo(0, channel.size(), socketChannel);
    channel.close();
    file.close();
    socketChannel.close();
  }
}

阻塞I/O下的伺服器實現

單線程逐個處理所有請求

使用阻塞I/O的伺服器，一般使用迴圈，逐個接受連接請求並讀取數據，然後處理下一個請求。

public class IOServer {

  private static final Logger LOGGER = LoggerFactory.getLogger(IOServer.class);

  public static void main(String[] args) {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket();
      serverSocket.bind(new InetSocketAddress(2345));
    } catch (IOException ex) {
      LOGGER.error("Listen failed", ex);
      return;
    }
    try{
      while(true) {
        Socket socket = serverSocket.accept();
        InputStream inputstream = socket.getInputStream();
        LOGGER.info("Received message {}", IOUtils.toString(new InputStreamReader(inputstream)));
      }
    } catch(IOException ex) {
      try {
        serverSocket.close();
      } catch (IOException e) {
      }
      LOGGER.error("Read message failed", ex);
    }
  }
}

為每個請求創建一個線程

上例使用單線程逐個處理所有請求，同一時間只能處理一個請求，等待I/O的過程浪費大量CPU資源，同時無法充分使用多CPU的優勢。下麵是使用多線程對阻塞I/O模型的改進。一個連接建立成功後，創建一個單獨的線程處理其I/O操作。

public class IOServerMultiThread {

  private static final Logger LOGGER = LoggerFactory.getLogger(IOServerMultiThread.class);

  public static void main(String[] args) {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket();
      serverSocket.bind(new InetSocketAddress(2345));
    } catch (IOException ex) {
      LOGGER.error("Listen failed", ex);
      return;
    }
    try{
      while(true) {
        Socket socket = serverSocket.accept();
        new Thread( () -> {
          try{
            InputStream inputstream = socket.getInputStream();
            LOGGER.info("Received message {}", IOUtils.toString(new InputStreamReader(inputstream)));
          } catch (IOException ex) {
            LOGGER.error("Read message failed", ex);
          }
        }).start();
      }
    } catch(IOException ex) {
      try {
        serverSocket.close();
      } catch (IOException e) {
      }
      LOGGER.error("Accept connection failed", ex);
    }
  }
}

使用線程池處理請求

為了防止連接請求過多，導致伺服器創建的線程數過多，造成過多線程上下文切換的開銷。可以通過線程池來限制創建的線程數，如下所示。

public class IOServerThreadPool {

  private static final Logger LOGGER = LoggerFactory.getLogger(IOServerThreadPool.class);

  public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket();
      serverSocket.bind(new InetSocketAddress(2345));
    } catch (IOException ex) {
      LOGGER.error("Listen failed", ex);
      return;
    }
    try{
      while(true) {
        Socket socket = serverSocket.accept();
        executorService.submit(() -> {
          try{
            InputStream inputstream = socket.getInputStream();
            LOGGER.info("Received message {}", IOUtils.toString(new InputStreamReader(inputstream)));
          } catch (IOException ex) {
            LOGGER.error("Read message failed", ex);
          }
        });
      }
    } catch(IOException ex) {
      try {
        serverSocket.close();
      } catch (IOException e) {
      }
      LOGGER.error("Accept connection failed", ex);
    }
  }
}

Reactor模式

精典Reactor模式

精典的Reactor模式示意圖如下所示。

在Reactor模式中，包含如下角色

  • Reactor 將I/O事件發派給對應的Handler
  • Acceptor 處理客戶端連接請求
  • Handlers 執行非阻塞讀/寫

最簡單的Reactor模式實現代碼如下所示。

public class NIOServer {

  private static final Logger LOGGER = LoggerFactory.getLogger(NIOServer.class);

  public static void main(String[] args) throws IOException {
    Selector selector = Selector.open();
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);
    serverSocketChannel.bind(new InetSocketAddress(1234));
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

    while (selector.select() > 0) {
      Set<SelectionKey> keys = selector.selectedKeys();
      Iterator<SelectionKey> iterator = keys.iterator();
      while (iterator.hasNext()) {
        SelectionKey key = iterator.next();
        iterator.remove();
        if (key.isAcceptable()) {
          ServerSocketChannel acceptServerSocketChannel = (ServerSocketChannel) key.channel();
          SocketChannel socketChannel = acceptServerSocketChannel.accept();
          socketChannel.configureBlocking(false);
          LOGGER.info("Accept request from {}", socketChannel.getRemoteAddress());
          socketChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
          SocketChannel socketChannel = (SocketChannel) key.channel();
          ByteBuffer buffer = ByteBuffer.allocate(1024);
          int count = socketChannel.read(buffer);
          if (count <= 0) {
            socketChannel.close();
            key.cancel();
            LOGGER.info("Received invalide data, close the connection");
            continue;
          }
          LOGGER.info("Received message {}", new String(buffer.array()));
        }
        keys.remove(key);
      }
    }
  }
}

為了方便閱讀，上示代碼將Reactor模式中的所有角色放在了一個類中。

從上示代碼中可以看到，多個Channel可以註冊到同一個Selector對象上，實現了一個線程同時監控多個請求狀態（Channel）。同時註冊時需要指定它所關註的事件，例如上示代碼中socketServerChannel對象只註冊了OP_ACCEPT事件，而socketChannel對象只註冊了OP_READ事件。

selector.select()是阻塞的，當有至少一個通道可用時該方法返回可用通道個數。同時該方法只捕獲Channel註冊時指定的所關註的事件。

多工作線程Reactor模式

經典Reactor模式中，儘管一個線程可同時監控多個請求（Channel），但是所有讀/寫請求以及對新連接請求的處理都在同一個線程中處理，無想充分利用多CPU的優勢，同時讀/寫操作也會阻塞對新連接請求的處理。因此可以引入多線程，並行處理多個讀/寫操作，如下圖所示。

多線程Reactor模式示例代碼如下所示。

public class NIOServer {

  private static final Logger LOGGER = LoggerFactory.getLogger(NIOServer.class);

  public static void main(String[] args) throws IOException {
    Selector selector = Selector.open();
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);
    serverSocketChannel.bind(new InetSocketAddress(1234));
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
      if(selector.selectNow() < 0) {
        continue;
      }
      Set<SelectionKey> keys = selector.selectedKeys();
      Iterator<SelectionKey> iterator = keys.iterator();
      while(iterator.hasNext()) {
        SelectionKey key = iterator.next();
        iterator.remove();
        if (key.isAcceptable()) {
          ServerSocketChannel acceptServerSocketChannel = (ServerSocketChannel) key.channel();
          SocketChannel socketChannel = acceptServerSocketChannel.accept();
          socketChannel.configureBlocking(false);
          LOGGER.info("Accept request from {}", socketChannel.getRemoteAddress());
          SelectionKey readKey = socketChannel.register(selector, SelectionKey.OP_READ);
          readKey.attach(new Processor());
        } else if (key.isReadable()) {
          Processor processor = (Processor) key.attachment();
          processor.process(key);
        }
      }
    }
  }
}

從上示代碼中可以看到，註冊完SocketChannel的OP_READ事件後，可以對相應的SelectionKey attach一個對象（本例中attach了一個Processor對象，該對象處理讀請求），並且在獲取到可讀事件後，可以取出該對象。

註：attach對象及取出該對象是NIO提供的一種操作，但該操作並非Reactor模式的必要操作，本文使用它，只是為了方便演示NIO的介面。

具體的讀請求處理在如下所示的Processor類中。該類中設置了一個靜態的線程池處理所有請求。而process方法並不直接處理I/O請求，而是把該I/O操作提交給上述線程池去處理，這樣就充分利用了多線程的優勢，同時將對新連接的處理和讀/寫操作的處理放在了不同的線程中，讀/寫操作不再阻塞對新連接請求的處理。

public class Processor {
  private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class);
  private static final ExecutorService service = Executors.newFixedThreadPool(16);

  public void process(SelectionKey selectionKey) {
    service.submit(() -> {
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
      int count = socketChannel.read(buffer);
      if (count < 0) {
        socketChannel.close();
        selectionKey.cancel();
        LOGGER.info("{}\t Read ended", socketChannel);
        return null;
      } else if(count == 0) {
        return null;
      }
      LOGGER.info("{}\t Read message {}", socketChannel, new String(buffer.array()));
      return null;
    });
  }
}

多Reactor

Netty中使用的Reactor模式，引入了多Reactor，也即一個主Reactor負責監控所有的連接請求，多個子Reactor負責監控並處理讀/寫請求，減輕了主Reactor的壓力，降低了主Reactor壓力太大而造成的延遲。
並且每個子Reactor分別屬於一個獨立的線程，每個成功連接後的Channel的所有操作由同一個線程處理。這樣保證了同一請求的所有狀態和上下文在同一個線程中，避免了不必要的上下文切換，同時也方便了監控請求響應狀態。

多Reactor模式示意圖如下所示。

多Reactor示例代碼如下所示。

public class NIOServer {

  private static final Logger LOGGER = LoggerFactory.getLogger(NIOServer.class);

  public static void main(String[] args) throws IOException {
    Selector selector = Selector.open();
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);
    serverSocketChannel.bind(new InetSocketAddress(1234));
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

    int coreNum = Runtime.getRuntime().availableProcessors();
    Processor[] processors = new Processor[coreNum];
    for (int i = 0; i < processors.length; i++) {
      processors[i] = new Processor();
    }

    int index = 0;
    while (selector.select() > 0) {
      Set<SelectionKey> keys = selector.selectedKeys();
      for (SelectionKey key : keys) {
        keys.remove(key);
        if (key.isAcceptable()) {
          ServerSocketChannel acceptServerSocketChannel = (ServerSocketChannel) key.channel();
          SocketChannel socketChannel = acceptServerSocketChannel.accept();
          socketChannel.configureBlocking(false);
          LOGGER.info("Accept request from {}", socketChannel.getRemoteAddress());
          Processor processor = processors[(int) ((index++) / coreNum)];
          processor.addChannel(socketChannel);
        }
      }
    }
  }
}

如上代碼所示，本文設置的子Reactor個數是當前機器可用核數的兩倍（與Netty預設的子Reactor個數一致）。對於每個成功連接的SocketChannel，通過round robin的方式交給不同的子Reactor。

子Reactor對SocketChannel的處理如下所示。

public class Processor {
  private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class);
  private static final ExecutorService service =
      Executors.newFixedThreadPool(2 * Runtime.getRuntime().availableProcessors());

  private Selector selector;

  public Processor() throws IOException {
    this.selector = SelectorProvider.provider().openSelector();
    start();
  }

  public void addChannel(SocketChannel socketChannel) throws ClosedChannelException {
    socketChannel.register(this.selector, SelectionKey.OP_READ);
  }

  public void start() {
    service.submit(() -> {
      while (true) {
        if (selector.selectNow() <= 0) {
          continue;
        }
        Set<SelectionKey> keys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = keys.iterator();
        while (iterator.hasNext()) {
          SelectionKey key = iterator.next();
          iterator.remove();
          if (key.isReadable()) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            SocketChannel socketChannel = (SocketChannel) key.channel();
            int count = socketChannel.read(buffer);
            if (count < 0) {
              socketChannel.close();
              key.cancel();
              LOGGER.info("{}\t Read ended", socketChannel);
              continue;
            } else if (count == 0) {
              LOGGER.info("{}\t Message size is 0", socketChannel);
              continue;
            } else {
              LOGGER.info("{}\t Read message {}", socketChannel, new String(buffer.array()));
            }
          }
        }
      }
    });
  }
}

在Processor中，同樣創建了一個靜態的線程池，且線程池的大小為機器核數的兩倍。每個Processor實例均包含一個Selector實例。同時每次獲取Processor實例時均提交一個任務到該線程池，並且該任務正常情況下一直迴圈處理，不會停止。而提交給該Processor的SocketChannel通過在其Selector註冊事件，加入到相應的任務中。由此實現了每個子Reactor包含一個Selector對象，並由一個獨立的線程處理。

Java進階系列


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Netty構建分散式消息隊列（AvatarMQ）設計指南之架構篇
    目前業界流行的分散式消息隊列系統（或者可以叫做消息中間件）種類繁多，比如，基於Erlang的RabbitMQ、基於Java的ActiveMQ/Apache Kafka、基於C/C++的ZeroMQ等等，都能進行大批量的消息路由轉發。它們的共同特點是，都有一個消息中轉路由節點，按照消息隊列裡面的專業術 ...
  • Effective c++讀書筆記
    1、視C++為一個語言聯邦 C、object-oriented C++、template C++、STL 2、儘可能使用const： 1）關鍵字const出現的星號左邊，表示被指物事常量；如果出現在星號右邊，表示指針自身是常量；如果出現在兩邊，表示被指物和指針都是常量。 2）stl迭代器中申明迭代器 ...
  • 解決Visual C++ Redistributable for Visual Studio 2015的安裝問題
    1. Visual C++ Redistributable for Visual Studio 2015系統要求：Windows 7情況下必須是Windows 7 with SP1.或者Windows10 2.系統檢測方法:命令行輸入winver.exe回車，如果你的windows版本是7600，需 ...
  • 今天寫項目時，突然發現canvas的一些公式不記得了，所以整理了一番，分享給大家。
    Canvas 設置開始繪圖位置：ctx.moveTo(x,y); 設置直線到的位置：ctx.lineTo(x,y); 描邊繪製：ctx.stroke(); 填充繪製：ctx.fill(); 自動閉合路徑：ctx.closePath(); 開啟新的繪製：ctx.beginPath(); 設置描邊顏色： ...
  • 淺入淺出dubbo
    1. Dubbo是什麼？ 只是一個框架 Hibernate是持久層框架，SpringMVC是MVC的框架，而Dubbo是分散式服務框架。 是框架而不是服務 所以不是像Tomcat或Memcached可以單獨啟動，它必須依附於應用才有意義。引入dubbo.jar的應用，並完成適合的配置後，這個應用就成 ...
  • [轉]看部電影，透透徹徹理解IoC(你沒有理由再迷惑!)
    之前對依賴註入的概念一直感到模糊，直到看了這篇文章：http://www.iteye.com/topic/1122835 引述： IoC（控制反轉：Inverse of Control）是Spring容器的內核，AOP、聲明式事務等功能在此基礎上開花結果。但是IoC這個重要的概念卻比較晦澀隱諱，不容 ...
  • 【GOF23設計模式】工廠模式
    來源：http://www.bjsxt.com/ 一、【GOF23設計模式】_簡單工廠模式詳解、面向對象設計原則、開閉原則、依賴反轉原則、迪米特法則 沒有工廠模式的情況 簡單工廠模式的情況 或者 二、【GOF23設計模式】_工廠方法模式詳解 三、【GOF23設計模式】_抽象工廠模式詳解 ...
  • 【GOF23設計模式】單例模式
    來源：http://www.bjsxt.com/ 一、【GOF23設計模式】_單例模式、應用場景、餓漢式、懶漢式 1、GOF23設計模式 2、單例模式 3、餓漢式 4、懶漢式 二、【GOF23設計模式】_單例模式、雙重檢查鎖式、靜態內部類式、枚舉式、UML類圖 雙重檢測鎖實現 靜態內部類實現 枚舉實 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類