標籤: 網頁設計公司

【併發編程】摩爾定律失效“帶來”并行編程

access_timePosted on by admin

本博客系列是學習併發編程過程中的記錄總結。由於文章比較多，寫的時間也比較散，所以我整理了個目錄貼（傳送門），方便查閱。

併發和并行

在真正開始聊本文的主題之前，我們先來回顧下兩個老生常談的概念：併發和并行。

  • 併發：是指多個線程任務在同一個CPU上快速地輪換執行，由於切換的速度非常快，給人的感覺就是這些線程任務是在同時進行的，但其實併發只是一種邏輯上的同時進行；
  • 并行：是指多個線程任務在不同CPU上同時進行，是真正意義上的同時執行。

下面貼上一張圖來解釋下這兩個概念：

上圖中的咖啡就可以看成是CPU，上面的只有一個咖啡機，相當於只有一個CPU。想喝咖啡的人只有等前面的人製作完咖啡才能製作自己的開發，也就是同一時間只能有一個人在製作咖啡，這是一種併發模式。下面的圖中有兩個咖啡機，相當於有兩個CPU，同一時刻可以有兩個人同時製作咖啡，是一種并行模式。

我們發現并行編程中，很重要的一個特點是系統具有多核CPU。要是系統是單核的，也就談不上什麼并行編程了。那麼是什麼原因導致了現代CPU架構都是多核架構？如果CPU架構都是單核的架構我們是不是就能不要研究什麼并行編程了？

“摩爾定律”失效

上面章節中留下了一個問題：為什麼現代CPU都是多核架構。為了回答這個問題，我們先來了解一個定律–摩爾定律。

1965年，英特爾聯合創始人戈登·摩爾提出以自己名字命名的「摩爾定律」，意指集成電路上可容納的元器件的數量每隔 18 至 24 個月就會增加一倍，性能也將提升一倍。

根據摩爾定律，CPU的性能每隔18到24個月就能增長一倍。但是從現在的情況來看，單核CPU的主頻已經逼近了極限，以現在的製造工藝，很難再繼續提升單核CPU的主頻。也就是說摩爾定律已經失效。

雖然摩爾定律失效了，但是科技的進度對CPU性能的需求沒有停止。這個也難不倒我們偉大的硬件工程師。一個CPU的性能提升有限，我將兩個CPU拼在一起性能不就提升一倍了么。於是多核CPU的架構就出現了。

提高CPU工作主頻主要受到生產工藝的限制。由於CPU是在半導體硅片上製造的，在硅片上的元件之間需要導線進行聯接，由於在高頻狀態下要求導線越細越短越好，這樣才能減小導線分佈電容等雜散干擾以保證CPU運算正確。因此製造工藝的限制，是CPU主頻發展的最大障礙之一。

多核架構引發并行編程

為了繼續保持性能的高速發展，硬件工程師破天荒地想出了將多個CPU內核塞進一個CPU里的奇妙想法。由此，并行計算就被非常自然地推廣開來，隨之而來的問題也層出不窮，程序員的黑暗時期也隨之到來。簡化的硬件設計方案必然帶來軟件設計的複雜性。換句話說，軟件工程師正在為硬件工程師無法完成的工作負責，他們將摩爾定律失效的責任推給了軟件開發者。

所以，如何讓多個CPU有效並且正確地工作也就成了一門技術，甚至是很大的學問。比如，多線程間如何保證線程安全，如何正確理解線程間的無序性、可見性，如何盡可能地設計并行程序，如何將串行程序改造為并行程序。而對并行計算的研究，也就是希望給這片黑暗帶來光明。

總結

世界就是這樣一個矛盾體，併發編程能讓我們充分地利用CPU資源，提升系統性能。但是同時也給我們帶來了很多問題，比如線程上下文切換對性能消耗的問題、共享變量的線程安全問題、線程死鎖問題和線程間通信等問題。研究并行編程就是研究怎麼在享受多線程編程給我們帶來便利的同時又能規避多線程帶來的坑。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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

ceph中rbd的增量備份和恢復

access_timePosted on by admin

ceph中rbd的增量備份和恢復

ceph的文檔地址：

​ 在調研OpenStack中虛機的備份和恢復時，發現OpenStack和ceph緊密結合，使用ceph做OpenStack的後端簡直是不要太爽，於是調研了使用ceph中的塊設備rbd來對虛機進行增量備份和恢復。以下是虛機備份和恢復的實驗步驟：

1. 前言：

​ 快照的功能一般是基於時間點做一個標記，然後在某些需要的時候，將狀態恢復到標記的那個點，這個有一個前提是底層的數據沒有破壞，舉個簡單的例子，Vmware 裏面對虛擬機做了一個快照，然後做了一些系統的操作，想恢復快照，前提是存儲快照的存儲系統沒用破壞，一旦破壞了是無法恢復的。

​ ceph也有快照功能，同樣，在這裏的快照是用來保存存儲系統上的狀態的，數據的快照能成功恢復的前提是存儲系統是好的，而一旦存儲系統壞了，快照同時會失效的，所以最好是能夠將數據備份下來。本篇博客主要是調研使用ceph的rbd命令來對存儲設備進行基於快照的增量備份。

2. ceph中rbd的常用命令：

2.1列出存儲池

ceph osd pool ls

2.2 查看存儲池的內容

rbd ls --pool pool_name
例子
rbd ls --pool volumes

2.3 打快照

rbd snap create {pool-name}/{image-name}@{snap-name}
例如
rbd snap create volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v1

2.4 羅列快照

rbd snap ls {pool-name}/{image-name}
例如：
rbd snap ls volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3

2.5 創建image

rbd create --size {pool-name}/{image-name}

3. Nova實例的備份與恢復

以ceph做後端，在創建實例時，需要選擇一個系統盤，系統盤即是我們的目標數據盤。

備份實驗步驟：

  1. 創建虛機。
  2. 在時間點v1對虛機打快照。
  3. 導出從開始創建image到快照v1那個時間點的差異數據，可以視為全量備份。
  4. 使用dd命令寫入文件test.txt
  5. 在時間點v2對虛機打快照。
  6. 導出從開始創建image到快照v2那個時間點的差異數據，可以視為全量備份。
  7. 導出了從v1快照時間點到v2快照時間點的差異數據，可以視為增量備份。

上文實驗過程的數據：

v1時間點數據 + v1_v2之間數據 = v2 時間點數據

虛機的備份

1. 實例第一次快照：

rbd snap create volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v1

2. 第一次全量備份：

rbd export-diff volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v1 testimage_v1

這個命令是導出了從開始創建image到快照v1那個時間點的差異數據導出來了testimage_v1，導出成本地文件testimage_v1

3. 寫入文件

dd

寫入文件，以此显示出v1和v2之間的數據變化，並沒有其他作用。

4. 實例第二次快照

rbd snap create volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v2

5. 第二次全量備份：

rbd export-diff volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v2  testimage_v2

這個命令是導出了從開始創建image到快照v2那個時間點的差異數據導出來了testimage_v2，導出成本地文件testimage_v2

6. 增量備份

增量備份（第二次和第一次的差異文件）：

rbd export-diff volumes/volume-c18b9782-dc71-4ddc-bb7f-bc0037105ac3@v2 --from-snap v1 testimage_v1_v2

這個命令是導出了從v1快照時間點到v2快照時間點的差異數據，導出成本地文件testimage_v1_v2

注意：

rbd export-diff rbd/testimage testimage_now

這個是導出了從image創建到當前的時間點的差異數據。

虛機恢復

虛機的恢復過程使用的是剛剛上面提到的備份到本地的那些文件。

1.創建塊設備映像

2.將testimage_v1融入塊設備，恢復v1時間的狀態

3.將testimage_v2融入塊設備，恢復v2時間狀態

4.在2基礎上將v1_v2融入塊設備，恢復至v2時間狀態

上述實驗是全量恢復和增量恢復的兩種狀態。下文將詳細總結項目中增量備份和恢復的使用過程。

1. 創建塊設備映像image

首先隨便創建一個image,名稱大小都不限制，因為後面恢復的時候會覆蓋掉大小的信息

rbd create --size 2048 backups/testbacknew

2. 基於v2的時間點的快照做恢復

2.1 基於V2恢復

直接基於v2的時間點的快照做恢復

rbd import-diff testimage_v2 rbd/testbacknew
2.2 基於v1+ v1_v2數據恢復

直接基於v1的時間點的數據，和後面的增量的v1_v2數據(要按順序導入)

rbd import-diff testimage_v1 backups/testbacknew
rbd import-diff testimage_v1_v2 backups/testbacknew

​ 實際項目當中就是，定期做快照，然後導出某個時間點快照的數據，然後導出增量的快照的數據，就可以了

4. 實際使用

​ 在實際項目中使用就是，定期做快照，然後導出某個時間點快照的數據，然後導出增量的快照的數據。

例如：

備份：

​ 對所有的rbd的image做一個基礎快照，然後導出這個快照的數據，然後設置每天定時做快照，導出快照時間點之間的數據，這樣每天導出來的就是一個增量的數據了。

​ 設置循環周期，比如三天為一個周期。每三天循環一次，自動刪除三天前的備份。

恢復：

​ 從第一個快照導入，然後按照順序導入增量的快照即可。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

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

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

jdbc-mysql測試例子和源碼詳解

access_timePosted on by admin

目錄

簡介

什麼是JDBC

JDBC是一套連接和操作數據庫的標準、規範。通過提供DriverManager、Connection、Statement、ResultSet等接口將開發人員與數據庫提供商隔離，開發人員只需要面對JDBC接口，無需關心怎麼跟數據庫交互。

幾個重要的類

類名 作用
DriverManager 驅動管理器，用於註冊驅動，是獲取 Connection對象的入口
Driver 數據庫驅動，用於獲取Connection對象
Connection 數據庫連接，用於獲取Statement對象、管理事務
Statement sql執行器，用於執行sql
ResultSet 結果集，用於封裝和操作查詢結果
prepareCall 用於調用存儲過程

使用中的注意事項

  1. 記得釋放資源。另外，ResultSet和Statement的關閉都不會導致Connection的關閉。

  2. maven要引入oracle的驅動包，要把jar包安裝在本地倉庫或私服才行。

  3. 使用PreparedStatement而不是Statement。可以避免SQL注入，並且利用預編譯的特點可以提高效率。

使用例子

需求

使用JDBC對mysql數據庫的用戶表進行增刪改查。

工程環境

JDK：1.8

maven：3.6.1

IDE：sts4

mysql driver：8.0.15

mysql：5.7

主要步驟

一個完整的JDBC保存操作主要包括以下步驟：

  1. 註冊驅動（JDK6後會自動註冊，可忽略該步驟）;

  2. 通過DriverManager獲得Connection對象;

  3. 開啟事務;

  4. 通過Connection獲得PreparedStatement對象;

  5. 設置PreparedStatement的參數;

  6. 執行保存操作;

  7. 保存成功提交事務，保存失敗回滾事務;

  8. 釋放資源，包括Connection、PreparedStatement。

創建表

CREATE TABLE `demo_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '用戶id',
  `name` varchar(16) COLLATE utf8_unicode_ci NOT NULL COMMENT '用戶名',
  `age` int(3) unsigned DEFAULT NULL COMMENT '用戶年齡',
  `gmt_create` datetime DEFAULT NULL COMMENT '記錄創建時間',
  `gmt_modified` datetime DEFAULT NULL COMMENT '記錄最近修改時間',
  `deleted` bit(1) DEFAULT b'0' COMMENT '是否刪除',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_name` (`name`),
  KEY `index_age` (`age`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

創建項目

項目類型Maven Project，打包方式jar

引入依賴

<!-- junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- mysql驅動的jar包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
<!-- oracle驅動的jar包 -->
<!-- <dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc6</artifactId>
    <version>11.2.0.2.0</version>
</dependency> -->

注意：由於oracle商業版權問題，maven並不提供Oracle JDBC driver，需要將驅動包手動添加到本地倉庫或私服。

編寫jdbc.prperties

下面的url拼接了好幾個參數，主要為了避免亂碼和時區報錯的異常。

路徑：resources目錄下

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/github_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=true
#這裏指定了字符編碼和解碼格式，時區，是否加密傳輸
username=root
password=root
#注意，xml配置是&採用&amp;替代

如果是oracle數據庫，配置如下：

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@//localhost:1521/xe
username=system
password=root

獲得Connection對象

    private static Connection createConnection() throws Exception {
        // 導入配置文件
        Properties pro = new Properties();
        InputStream in = JDBCUtil.class.getClassLoader().getResourceAsStream( "jdbc.properties" );
        Connection conn = null;
        pro.load( in );
        // 獲取配置文件的信息
        String driver = pro.getProperty( "driver" );
        String url = pro.getProperty( "url" );
        String username = pro.getProperty( "username" );
        String password = pro.getProperty( "password" );
        // 註冊驅動,JDK6后不需要再手動註冊，DirverManager的靜態代碼塊會幫我們註冊
        // Class.forName(driver);
        // 獲得連接
        conn = DriverManager.getConnection( url, username, password );
        return conn;
    }

使用Connection對象完成保存操作

這裏簡單地模擬實際業務層調用持久層，並開啟事務。另外，獲取連接、開啟事務、提交回滾、釋放資源都通過自定義的工具類 JDBCUtil 來實現，具體見源碼。

    @Test
    public void save() {
        UserDao userDao = new UserDaoImpl();
        // 創建用戶
        User user = new User( "zzf002", 18, new Date(), new Date() );
        try {
            // 開啟事務
            JDBCUtil.startTrasaction();
            // 保存用戶
            userDao.insert( user );
            // 提交事務
            JDBCUtil.commit();
        } catch( Exception e ) {
            // 回滾事務
            JDBCUtil.rollback();
            e.printStackTrace();
        } finally {
            // 釋放資源
            JDBCUtil.release();
        }
    }

接下來看看具體的保存操作，即DAO層方法。

    public void insert( User user ) throws Exception {
        String sql = "insert into demo_user (name,age,gmt_create,gmt_modified) values(?,?,?,?)";
        Connection connection = JDBCUtil.getConnection();
        //獲取PreparedStatement對象
        PreparedStatement prepareStatement = connection.prepareStatement( sql );
        //設置參數
        prepareStatement.setString( 1, user.getName() );
        prepareStatement.setInt( 2, user.getAge() );
        prepareStatement.setDate( 3, new java.sql.Date( user.getGmt_create().getTime() ) );
        prepareStatement.setDate( 4, new java.sql.Date( user.getGmt_modified().getTime() ) );
        //執行保存
        prepareStatement.executeUpdate();
        //釋放資源
        JDBCUtil.release( prepareStatement, null );
    }

源碼分析

驅動註冊

DriverManager.registerDriver

DriverManager主要用於管理數據庫驅動，併為我們提供了獲取連接對象的接口。其中，它有一個重要的成員屬性registeredDrivers，是一個CopyOnWriteArrayList集合（通過ReentrantLock實現線程安全），存放的是元素是DriverInfo對象。

    //存放數據庫驅動包裝類的集合（線程安全）
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>(); 
    public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {
        //調用重載方法，傳入的DriverAction對象為null
        registerDriver(driver, null);
    }
    public static synchronized void registerDriver(java.sql.Driver driver,
            DriverAction da)
        throws SQLException {
        if(driver != null) {
            //當列表中沒有這個DriverInfo對象時，加入列表。
            //注意，這裏判斷對象是否已經存在，最終比較的是driver地址是否相等。
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }

為什麼集合存放的是Driver的包裝類DriverInfo對象，而不是Driver對象呢？

  1. 通過DriverInfo的源碼可知，當我們調用equals方法比較兩個DriverInfo對象是否相等時，實際上比較的是Driver對象的地址，也就是說，我可以在DriverManager中註冊多個MYSQL驅動。而如果直接存放的是Driver對象，就不能達到這種效果（因為沒有遇到需要註冊多個同類驅動的場景，所以我暫時理解不了這樣做的好處）。

  2. DriverInfo中還包含了另一個成員屬性DriverAction，當我們註銷驅動時，必須調用它的deregister方法后才能將驅動從註冊列表中移除，該方法決定註銷驅動時應該如何處理活動連接等（其實一般在構造DriverInfo進行註冊時，傳入的DriverAction對象為空，根本不會去使用到這個對象，除非一開始註冊就傳入非空DriverAction對象）。

綜上，集合中元素不是Driver對象而DriverInfo對象，主要考慮的是擴展某些功能，雖然這些功能幾乎不會用到。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

class DriverInfo {

    final Driver driver;
    DriverAction da;
    DriverInfo(Driver driver, DriverAction action) {
        this.driver = driver;
        da = action;
    }

    @Override
    public boolean equals(Object other) {
        //這裏對比的是地址
        return (other instanceof DriverInfo)
                && this.driver == ((DriverInfo) other).driver;
    }

}

為什麼Class.forName(com.mysql.cj.jdbc.Driver) 可以註冊驅動？

當加載com.mysql.cj.jdbc.Driver這個類時，靜態代碼塊中會執行註冊驅動的方法。

    static {
        try {
            //靜態代碼塊中註冊當前驅動
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

為什麼JDK6后不需要Class.forName也能註冊驅動？

因為從JDK6開始，DriverManager增加了以下靜態代碼塊，當類被加載時會執行static代碼塊的loadInitialDrivers方法。

而這個方法會通過查詢系統參數（jdbc.drivers）和SPI機制兩種方式去加載數據庫驅動。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    static {
        loadInitialDrivers();
    }
    //這個方法通過兩個渠道加載所有數據庫驅動：
    //1. 查詢系統參數jdbc.drivers獲得數據驅動類名
    //2. SPI機制
    private static void loadInitialDrivers() {
        //通過系統參數jdbc.drivers讀取數據庫驅動的全路徑名。該參數可以通過啟動參數來設置，其實引入SPI機制后這一步好像沒什麼意義了。
        String drivers;
        try {
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
        //使用SPI機制加載驅動
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                //讀取META-INF/services/java.sql.Driver文件的類全路徑名。
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                //加載並初始化類
                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }
                return null;
            }
        });

        if (drivers == null || drivers.equals("")) {
            return;
        }
        //加載jdbc.drivers參數配置的實現類
        String[] driversList = drivers.split(":");
        for (String aDriver : driversList) {
            try {
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }

補充：SPI機制本質上提供了一種服務發現機制，通過配置文件的方式，實現服務的自動裝載，有利於解耦和面向接口編程。具體實現過程為：在項目的META-INF/services文件夾下放入以接口全路徑名命名的文件，並在文件中加入實現類的全限定名，接着就可以通過ServiceLoder動態地加載實現類。

打開mysql的驅動包就可以看到一個java.sql.Driver文件，裏面就是mysql驅動的全路徑名。

獲得連接對象

DriverManager.getConnection

獲取連接對象的入口是DriverManager.getConnection，調用時需要傳入url、username和password。

獲取連接對象需要調用java.sql.Driver實現類（即數據庫驅動）的方法，而具體調用哪個實現類呢？

正如前面講到的，註冊的數據庫驅動被存放在registeredDrivers中，所以只有從這個集合中獲取就可以了。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    public static Connection getConnection(String url, String user, String password) throws SQLException {
        java.util.Properties info = new java.util.Properties();

        if (user != null) {
            info.put("user", user);
        }
        if (password != null) {
            info.put("password", password);
        }
        //傳入url、包含username和password的信息類、當前調用類
        return (getConnection(url, info, Reflection.getCallerClass()));
    }
    private static Connection getConnection(String url, java.util.Properties info, Class<?> caller) throws SQLException {
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        //遍歷所有註冊的數據庫驅動
        for(DriverInfo aDriver : registeredDrivers) {
            //先檢查這當前類加載器是否有權限加載這個驅動，如果是才進入
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                //這一步是關鍵，會去調用Driver的connect方法
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    return con;
                }
            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }
        }
    }

com.mysql.cj.jdbc.Driver.connection

由於使用的是mysql的數據驅動，這裏實際調用的是com.mysql.cj.jdbc.Driver的方法。

從以下代碼可以看出，mysql支持支持多節點部署的策略，本文僅對單機版進行擴展。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    //mysql支持多節點部署的策略，根據架構不同，url格式也有所區別。
    private static final String REPLICATION_URL_PREFIX = "jdbc:mysql:replication://";
    private static final String URL_PREFIX = "jdbc:mysql://";
    private static final String MXJ_URL_PREFIX = "jdbc:mysql:mxj://";
    public static final String LOADBALANCE_URL_PREFIX = "jdbc:mysql:loadbalance://";
    public java.sql.Connection connect(String url, Properties info) throws SQLException {
        //根據url的類型來返回不同的連接對象，這裏僅考慮單機版
        ConnectionUrl conStr = ConnectionUrl.getConnectionUrlInstance(url, info);
        switch (conStr.getType()) {
            case SINGLE_CONNECTION:
                //調用ConnectionImpl.getInstance獲取連接對象
                return com.mysql.cj.jdbc.ConnectionImpl.getInstance(conStr.getMainHost());

            case LOADBALANCE_CONNECTION:
                return LoadBalancedConnectionProxy.createProxyInstance((LoadbalanceConnectionUrl) conStr);

            case FAILOVER_CONNECTION:
                return FailoverConnectionProxy.createProxyInstance(conStr);

            case REPLICATION_CONNECTION:
                return ReplicationConnectionProxy.createProxyInstance((ReplicationConnectionUrl) conStr);

            default:
                return null;
        }
    }

ConnectionImpl.getInstance

這個類有個比較重要的字段session，可以把它看成一個會話，和我們平時瀏覽器訪問服務器的會話差不多，後續我們進行數據庫操作就是基於這個會話來實現的。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    private NativeSession session = null;
    public static JdbcConnection getInstance(HostInfo hostInfo) throws SQLException {
        //調用構造
        return new ConnectionImpl(hostInfo);
    }
    public ConnectionImpl(HostInfo hostInfo) throws SQLException {
        //先根據hostInfo初始化成員屬性，包括數據庫主機名、端口、用戶名、密碼、數據庫及其他參數設置等等，這裏省略不放入。
        //最主要看下這句代碼 
        createNewIO(false);
    }
    public void createNewIO(boolean isForReconnect) {
        if (!this.autoReconnect.getValue()) {
            //這裏只看不重試的方法
            connectOneTryOnly(isForReconnect);
            return;
        }

        connectWithRetries(isForReconnect);
    }
    private void connectOneTryOnly(boolean isForReconnect) throws SQLException {

        JdbcConnection c = getProxy();
        //調用NativeSession對象的connect方法建立和數據庫的連接
        this.session.connect(this.origHostInfo, this.user, this.password, this.database, DriverManager.getLoginTimeout() * 1000, c);
        return;
    }

NativeSession.connect

接下來的代碼主要是建立會話的過程，首先時建立物理連接，然後根據協議建立會話。

注意：考慮篇幅，以下代碼經過修改，僅保留所需部分。

    public void connect(HostInfo hi, String user, String password, String database, int loginTimeout, TransactionEventHandler transactionManager)
            throws IOException {
        //首先獲得TCP/IP連接
        SocketConnection socketConnection = new NativeSocketConnection();
        socketConnection.connect(this.hostInfo.getHost(), this.hostInfo.getPort(), this.propertySet, getExceptionInterceptor(), this.log, loginTimeout);

        // 對TCP/IP連接進行協議包裝
        if (this.protocol == null) {
            this.protocol = NativeProtocol.getInstance(this, socketConnection, this.propertySet, this.log, transactionManager);
        } else {
            this.protocol.init(this, socketConnection, this.propertySet, transactionManager);
        }

        // 通過用戶名和密碼連接指定數據庫，並創建會話
        this.protocol.connect(user, password, database);
    }

針對數據庫的連接，暫時點到為止，另外還有涉及數據庫操作的源碼分析，後續再完善補充。

本文為原創文章，轉載請附上原文出處鏈接：https://github.com/ZhangZiSheng001/jdbc-demo

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

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

※想要讓你的商品在網路上成為最夯、最多人討論的話題?

※高價收購3C產品,價格不怕你比較

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

對js中局部變量、全局變量和閉包的理解

access_timePosted on by admin

對js中局部變量、全局變量和閉包的理解

局部變量

對於局部變量，js給出的定義是這樣的：在 JavaScript函數內部聲明的變量（使用 var）是局部變量，所以只能在函數內部訪問它。（該變量的作用域是局部的）。可以在不同的函數中使用名稱相同的局部變量，因為只有聲明過該變量的函數才能識別出該變量。只要函數運行完畢，本地變量就會被刪除。

我們先來逐步理解：

  • 只能在函數內部訪問

    function test() {
    var a = 0;
    return a;
}

console.log(a);
//結果：a is not defined

    上面的代碼聲明了一個test()函數，在函數內部聲明了一個局部變量a，當我們嘗試在函數外訪問局部變量a時，出來的結果是a is not defined

    我們再來看下面這個例子：

    function test() {
    var a = 0;
    return a;
}

console.log(test());
//結果：0

    以上兩個例子很好的闡述了局部變量只能在函數內部訪問，當調用函數時，函數域自動執行其中的代碼，局部變量自然也被調用。

  • 只要函數運行完畢，本地變量就會被刪除

    function b() {
    var y = 0;
    z = ++y;
    console.log("這是局部變量y：",z)
    return z;
}

console.log(b(),b(),b());
//結果：這是局部變量y： 1
//這是局部變量y： 1
//這是局部變量y： 1
//1 1 1

    從上面代碼我們可以看出，我們執行了3次函數調用，得到的結果都是1，可能有人會說，這很簡單啊，每次出來的結果都是1，那是因為每次執行函數，函數內都會將局部變量y初始化為0。沒錯，的確是這樣，但是如果不初始化變量，則得到的返回值是NaN,所以初始化是必要的。所以，無論用什麼辦法，在函數內部用一個局部變量去做累加，是不可能實現的。但是，我們可以通過全局變量和閉包來實現累加。

全局變量

在js中，這樣定義全局變量， 在函數外聲明的變量是全局變量，網頁上的所有腳本和函數都能訪問它。 全局變量會在頁面關閉后被刪除。

  • 我們再來看一個例子

    var a = 0;

function b() {
    ++a;
    console.log("這是全局變量a",a);
    return a;
}
console.log("這是未改變的全局變量a:",a,"這是函數b():",b(),b(),b(),"這是改變后的全局變量a:",a);
//結果：這是全局變量a 1
//這是全局變量a 2
//這是全局變量a 3
//這是未改變的全局變量a: 0 這是函數b(): 1 2 3 這是改變后的全局變量a: 3

    上面代碼定義了一個全局變量a，和一個b()函數，通過函數內部對a執行自加加，實現了累加目的，通過三次調用函數，得到的結果a為3。

閉包

什麼是閉包呢？閉包的定義是這樣的，閉包是一種保護私有變量的機制，在函數執行時形成私有的作用域，保護裏面的私有變量不受外界干擾。直觀的說就是形成一個不銷毀的棧環境。

我對閉包的理解是這樣的，閉包就是一個內嵌函數引用頂層函數的變量，而頂層函數是一個立即執行函數（自調用函數），因為它會自動調用，所以局部變量不會被刪除，但是這會增加內存消耗。

  • 來看一個例子

    function a() {
    var b = 0;
    return function() {
        return ++b;
    }
}

var closure = a();
console.log("這是閉包：",closure(),closure(),closure());
//結果：這是閉包： 1 2 3

    我們看到，由於閉包的特殊機制，使得局部變量在函數執行完之後不會被銷毀，由此得到的最後結果為3 ，而不是1。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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

go中的關鍵字-go(上)

access_timePosted on by admin

1. goroutine的使用

　　在Go語言中，表達式go f(x, y, z)會啟動一個新的goroutine運行函數f(x, y, z)，創建一個併發任務單元。即go關鍵字可以用來開啟一個goroutine(協程))進行任務處理。

　　創建單個goroutine

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func HelloWorld() {
 8     fmt.Println("Hello goroutine")
 9 }
10 
11 func main() {
12     go HelloWorld()      // 開啟一個新的併發運行
       time.Sleep(1*time.Second)
13     fmt.Println("后輸出消息！")
14 }

　　輸出

1 Hello goroutine
2 后輸出消息！

　　這裏的sleep是必須的，否則你可能看不到goroutine裡頭的輸出,或者裏面的消息后輸出。因為當main函數返回時，所有的gourutine都是暴力終結的，然後程序退出。

　　創建多個goroutine時

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func DelayPrint() {
 9     for i := 1; i <= 3; i++ {
10         time.Sleep(500 * time.Millisecond)
11         fmt.Println(i)
12     }
13 }
14 
15 func HelloWorld() {
16     fmt.Println("Hello goroutine")
17 }
18 
19 func main() {
20     go DelayPrint()     // 第一個goroutine
21     go HelloWorld()     // 第二個goroutine
22     time.Sleep(10*time.Second)
23     fmt.Println("main func")
24 }

　　輸出

1 Hello  goroutine
2 1
3 2
4 3
5 4
6 
7 main func

　　當去掉 DelayPrint() 函數里的sleep之後，輸出為：

1 1
2 2
3 3
4 4
5 Hello goroutine
6 main function

　　說明第二個goroutine不會因為第一個而堵塞或者等待。事實是當程序執行go FUNC()的時候，只是簡單的調用然後就立即返回了，並不關心函數裡頭發生的故事情節，所以不同的goroutine直接不影響，main會繼續按順序執行語句。

goroutine阻塞

　　場景一：

1 package main
2 
3 func main() {
4     ch := make(chan int)
5     <- ch // 阻塞main goroutine, 通道被鎖
6 }

　　運行程序會報錯：

1 fatal error: all goroutines are asleep - deadlock!
2 
3 goroutine 1 [chan receive]:
4 main.main()

　　場景二

 1 package main
 2 
 3 func main() {
 4     ch1, ch2 := make(chan int), make(chan int)
 5 
 6     go func() {
 7         ch1 <- 1 // ch1通道的數據沒有被其他goroutine讀取走，堵塞當前goroutine
 8         ch2 <- 0
 9     }()
10 
11     <- ch2 // ch2 等待數據的寫
12 }

　　非緩衝通道上如果只有數據流入，而沒有流出，或者只流出無流入，都會引起阻塞。 goroutine的非緩衝通道裡頭一定要一進一出，成對出現。 上面例子，一：流出無流入；二：流入無流出。

　　處理方式：

　　1. 讀取通道數據

 1 package main
 2 
 3 func main() {
 4     ch1, ch2 := make(chan int), make(chan int)
 5 
 6     go func() {
 7         ch1 <- 1 // ch1通道的數據沒有被其他goroutine讀取走，堵塞當前goroutine
 8         ch2 <- 0
 9     }()
10 
11     <- ch1 // 取走便是
12     <- ch2 // chb 等待數據的寫
13 }

　　2. 創建緩衝通道

 1 package main
 2 
 3 func main() {
 4     ch1, ch2 := make(chan int, 3), make(chan int)
 5 
 6     go func() {
 7         ch1 <- 1 // cha通道的數據沒有被其他goroutine讀取走，堵塞當前goroutine
 8         ch2 <- 0
 9     }()
10 
11     <- ch2 // ch2 等待數據的寫
12 }

2. goroutine調度器相關結構

　　goroutine的調度涉及到幾個重要的數據結構，我們先逐一介紹和分析這幾個數據結構。這些數據結構分別是結構體G，結構體M，結構體P，以及Sched結構體。前三個的定義在文件runtime/runtime.h中，而Sched的定義在runtime/proc.c中。Go語言的調度相關實現也是在文件proc.c中。

2.1 結構體G

　　g是goroutine的縮寫，是goroutine的控制結構，是對goroutine的抽象。看下它內部主要的一些結構：

 1 type g struct {
 2    //堆棧參數。
 3      //堆棧描述了實際的堆棧內存：[stack.lo，stack.hi）。
 4      // stackguard0是在Go堆棧增長序言中比較的堆棧指針。
 5      //通常是stack.lo + StackGuard，但是可以通過StackPreempt觸發搶佔。
 6      // stackguard1是在C堆棧增長序言中比較的堆棧指針。
 7      //它是g0和gsignal堆棧上的stack.lo + StackGuard。
 8      //在其他goroutine堆棧上為〜0，以觸發對morestackc的調用（並崩潰）。

 9   //當前g使用的棧空間，stack結構包括 [lo, hi]兩個成員
10     stack       stack   // offset known to runtime/cgo

11   // 用於檢測是否需要進行棧擴張，go代碼使用
12     stackguard0 uintptr // offset known to liblink

13   // 用於檢測是否需要進行棧擴展，原生代碼使用的
14     stackguard1 uintptr // offset known to liblink

15   // 當前g所綁定的m
16     m              *m      // current m; offset known to arm liblink

17   // 當前g的調度數據，當goroutine切換時，保存當前g的上下文，用於恢復
18     sched          gobuf

19     // goroutine運行的函數
20     fnstart        *FuncVal        
21     // g當前的狀態
22     atomicstatus   uint32
23   // 當前g的id
24     goid           int64

25      // 狀態Gidle,Grunnable,Grunning,Gsyscall,Gwaiting,Gdead
26     status   int16

27   // 下一個g的地址，通過guintptr結構體的ptr set函數可以設置和獲取下一個g，通過這個字段和sched.gfreeStack sched.gfreeNoStack 可以把 free g串成一個鏈表
28     schedlink      guintptr

29   // 判斷g是否允許被搶佔
30     preempt        bool       // preemption signal, duplicates stackguard0 = stackpreempt

31     // g是否要求要回到這個M執行, 有的時候g中斷了恢復會要求使用原來的M執行
32     lockedm        muintptr

33     // 用於傳遞參數，睡眠時其它goroutine設置param，喚醒時此goroutine可以獲取
       param  *void

34    // 創建這個goroutine的go表達式的pc
35    uintptr    gopc
36 }

　　其中包含了棧信息stackbase和stackguard，有運行的函數信息fnstart。這些就足夠成為一個可執行的單元了，只要得到CPU就可以運行。goroutine切換時，上下文信息保存在結構體的sched域中。goroutine切換時，上下文信息保存在結構體的sched域中。goroutine是輕量級的線程或者稱為協程，切換時並不必陷入到操作系統內核中，很輕量級。

　　結構體G中的Gobuf，其實只保存了當前棧指針，程序計數器，以及goroutine自身。

1 struct Gobuf
2 {
3     //這些字段的偏移是libmach已知的（硬編碼的）。
4     sp   uintper;
5     pc   *byte;
6     g    *G;
7     ...
8 };

　　記錄g是為了恢復當前goroutine的結構體G指針，運行時庫中使用了一個常駐的寄存器extern register G* g，這是當前goroutine的結構體G的指針。這種結構是為了快速地訪問goroutine中的信息，比如，Go的棧的實現並沒有使用%ebp寄存器，不過這可以通過g->stackbase快速得到。”extern register”是由6c，8c等實現的一個特殊的存儲，在ARM上它是實際的寄存器。在linux系統中，對g和m使用的分別是0(GS)和4(GS)。鏈接器還會根據特定操作系統改變編譯器的輸出，每個鏈接到Go程序的C文件都必須包含runtime.h頭文件，這樣C編譯器知道避免使用專用的寄存器。

2.2 結構體P

　　P是Processor的縮寫。結構體P的加入是為了提高Go程序的併發度，實現更好的調度。M代表OS線程。P代表Go代碼執行時需要的資源。

 1 type p struct {
 2    lock mutex
 3 
 4    id          int32
 5    // p的狀態，稍後介紹
 6    status      uint32 // one of pidle/prunning/...
 7 
 8    // 下一個p的地址，可參考 g.schedlink
 9    link        puintptr
10    // p所關聯的m
11    m           muintptr   // back-link to associated m (nil if idle)
12 
13    // 內存分配的時候用的，p所屬的m的mcache用的也是這個
14    mcache      *mcache
15   
16    // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
17    // 從sched中獲取並緩存的id，避免每次分配goid都從sched分配
18      goidcache    uint64
19      goidcacheend uint64
20 
21    // Queue of runnable goroutines. Accessed without lock.
22    // p 本地的runnbale的goroutine形成的隊列
23    runqhead uint32
24    runqtail uint32
25    runq     [256]guintptr
26 
27    // runnext，如果不是nil，則是已準備好運行的G
28    //當前的G，並且應該在下一個而不是其中運行
29    // runq，如果運行G的時間還剩時間
30    //切片。它將繼承當前時間剩餘的時間
31    //切片。如果一組goroutine鎖定在
32    //交流等待模式，該計劃將其設置為
33    //單位並消除（可能很大）調度
34    //否則會由於添加就緒商品而引起的延遲
35    // goroutines到運行隊列的末尾。
36 
37    // 下一個執行的g，如果是nil，則從隊列中獲取下一個執行的g
38    runnext guintptr
39 
40    // Available G's (status == Gdead)
41    // 狀態為 Gdead的g的列表，可以進行復用
42    gfree    *g
43    gfreecnt int32
44 }

　　跟G不同的是，P不存在waiting狀態。MCache被移到了P中，但是在結構體M中也還保留着。在P中有一個Grunnable的goroutine隊列，這是一個P的局部隊列。當P執行Go代碼時，它會優先從自己的這個局部隊列中取，這時可以不用加鎖，提高了併發度。如果發現這個隊列空了，則去其它P的隊列中拿一半過來，這樣實現工作流竊取的調度。這種情況下是需要給調用器加鎖的。

2.3 結構體M

　　M是machine的縮寫，是對機器的抽象，每個m都是對應到一條操作系統的物理線程。

 1 type m struct {
 2      // g0是用於調度和執行系統調用的特殊g
 3    g0      *g             // goroutine with scheduling stack
 4      // m當前運行的g
 5    curg    *g             // current running goroutine
 6    // 當前擁有的p
 7    p        puintptr      // attached p for executing go code (nil if not executing go code)

 8    // 線程的 local storage
 9    tls      [6]uintptr    // thread-local storage
10    // 喚醒m時，m會擁有這個p
11    nextp         puintptr
12    id            int64
13    // 如果 !="", 繼續運行curg
14    preemptoff    string   // if != "", keep curg running on this m

15    // 自旋狀態，用於判斷m是否工作已結束，並尋找g進行工作
16    spinning      bool     // m is out of work and is actively looking for work

17    // 用於判斷m是否進行休眠狀態
18    blocked       bool     // m is blocked on a note
19    // m休眠和喚醒通過這個，note裏面有一個成員key，對這個key所指向的地址進行值的修改，進而達到喚醒和休眠的目的
20    park          note

21    // 所有m組成的一個鏈表
22    alllink       *m       // on allm
23    // 下一個m，通過這個字段和sched.midle 可以串成一個m的空閑鏈表
24    schedlink     muintptr
25    // mcache，m擁有p的時候，會把自己的mcache給p
26    mcache        *mcache
27    // lockedm的對應值
28    lockedg       guintptr
29    // 待釋放的m的list，通過sched.freem 串成一個鏈表
30    freelink      *m      // on sched.freem
31 }

　　和G類似，M中也有alllink域將所有的M放在allm鏈表中。lockedg是某些情況下，G鎖定在這個M中運行而不會切換到其它M中去。M中還有一個MCache，是當前M的內存的緩存。M也和G一樣有一個常駐寄存器變量，代表當前的M。同時存在多個M，表示同時存在多個物理線程。

2.4 Sched結構體

　　Sched是調度實現中使用的數據結構，該結構體的定義在文件proc.c中。

 1 type schedt struct {
 2    // 全局的go id分配
 3    goidgen  uint64
 4    // 記錄的最後一次從i/o中查詢g的時間
 5    lastpoll uint64
 6 
 7    lock mutex
 8 
 9    //當增加nmidle，nmidlelocked，nmsys或nmfreed時，應
10    //確保調用checkdead（）。
11 
12      // m的空閑鏈表，結合m.schedlink 就可以組成一個空閑鏈表了
13    midle        muintptr // idle m's waiting for work
14    nmidle       int32    // number of idle m's waiting for work
15    nmidlelocked int32    // number of locked m's waiting for work
16    // 下一個m的id，也用來記錄創建的m數量
17    mnext        int64    // number of m's that have been created and next M ID
18    // 最多允許的m的數量
19    maxmcount    int32    // maximum number of m's allowed (or die)
20    nmsys        int32    // number of system m's not counted for deadlock
21    // free掉的m的數量，exit的m的數量
22    nmfreed      int64    // cumulative number of freed m's
23 
24    ngsys uint32 // 系統goroutine的數量；原子更新
25 
26    pidle      puintptr // 閑置的
27    npidle     uint32
28    nmspinning uint32 // See "Worker thread parking/unparking" comment in proc.go.
29 
30    // Global runnable queue.
31    // 這個就是全局的g的隊列了，如果p的本地隊列沒有g或者太多，會跟全局隊列進行平衡
32    // 根據runqhead可以獲取隊列頭的g，然後根據g.schedlink 獲取下一個，從而形成了一個鏈表
33    runqhead guintptr
34    runqtail guintptr
35    runqsize int32
36 
37    // freem是m等待被釋放時的列表
38    //設置了m.exited。通過m.freelink鏈接。
39 
40    // 等待釋放的m的列表
41    freem *m
42 }

　　大多數需要的信息都已放在了結構體M、G和P中，Sched結構體只是一個殼。可以看到，其中有M的idle隊列，P的idle隊列，以及一個全局的就緒的G隊列。Sched結構體中的Lock是非常必須的，如果M或P等做一些非局部的操作，它們一般需要先鎖住調度器。

3. G、P、M相關狀態

g.status

  • _Gidle: goroutine剛剛創建還沒有初始化
  • _Grunnable: goroutine處於運行隊列中，但是還沒有運行，沒有自己的棧
  • _Grunning: 這個狀態的g可能處於運行用戶代碼的過程中，擁有自己的m和p
  • _Gsyscall: 運行systemcall中
  • _Gwaiting: 這個狀態的goroutine正在阻塞中，類似於等待channel
  • _Gdead: 這個狀態的g沒有被使用，有可能是剛剛退出，也有可能是正在初始化中
  • _Gcopystack: 表示g當前的棧正在被移除，新棧分配中

goroutine的狀態變化

　　在newproc1中新建的goroutine被設置為Grunnable狀態，投入運行時設置成Grunning。Grunning狀態的goroutine會在entersyscall的時候goroutine的狀態被設置為Gsyscall，到出系統調用時根據它是從阻塞系統調用中出來還是非阻塞系統調用中出來，又會被設置成Grunning或者Grunnable的狀態。在goroutine最終退出的runtime.exit函數中，goroutine被設置為Gdead狀態。還會在進行I/O時可能會進入waiting狀態，主動讓出CPU，此時會被移到所屬P中的其他G後面，等待下一次輪到執行。

p.status

  • _Pidle: 空閑狀態，此時p不綁定m
  • _Prunning: m獲取到p的時候，p的狀態就是這個狀態了，然後m可以使用這個p的資源運行g
  • _Psyscall: 當go調用原生代碼，原生代碼又反過來調用go的時候，使用的p就會變成此態
  • _Pdead: 當運行中，需要減少p的數量時，被減掉的p的狀態就是這個了

m.status

m的status沒有p、g的那麼明確，但是在運行流程的分析中，主要有以下幾個狀態

  • 運行中: 拿到p，執行g的過程中
  • 運行原生代碼: 正在執行原聲代碼或者阻塞的syscall
  • 休眠中: m發現無待運行的g時，進入休眠，並加入到空閑列表中
  • 自旋中(spining): 當前工作結束，正在尋找下一個待運行的g

 

4. G、P、M的調度關係

　　一個G就是一個gorountine，保存了協程的棧、程序計數器以及它所在M的信息。P全稱是Processor，處理器，它的主要用途就是用來執行goroutine的。M代表內核級線程，一個M就是一個線程，goroutine就是跑在M之上的。程序啟動時，會創建一個主G，而每使用一次go關鍵字也創建一個G。go func()創建一個新的G后，放到P的本地隊列里，或者平衡到全局隊列，然後檢查是否有可用的M，然後喚醒或新建一個M，M獲取待執行的G和空閑的P，將調用參數保存到g的棧，將sp，pc等上下文環境保存在g的sched域，這樣整個goroutine就準備好了，只要等分配到CPU，它就可以繼續運行，之後再清理現場，重新進入調度循環。

4.1 調度實現

　　圖中有兩個物理線程，M0、M1每一個M都擁有一個處理器P，每一個P都有一個正在運行的G。P的數量可以通過GOMAXPROCS()來設置，它其實也代表了真正的併發度，即有多少個goroutine可以同時運行。圖中灰色goroutine都是處於ready的就緒態，正在等待被調度。由P維護這個就緒隊列（runqueue），go function每啟動一個goroutine，runqueue隊列就在其末尾加入一個goroutine，在下一個調度點，就從runqueue中取出一個goroutine執行。

　　當一個OS線程M0陷入阻塞時，P轉而在M1上運行G，圖中的M1可能是正被創建，或者從線程緩存中取出。當MO返回時，它嘗試取得一個P來運行goroutine，一般情況下，它會從其他的OS線程那裡拿一個P過來執行，像M1獲取P一樣；如果沒有拿到的話，它就把goroutine放在一個global runqueue（全局運行隊列）里，然後自己睡眠（放入線程緩存里）。所有的P會周期性的檢查全局隊列並運行其中的goroutine，否則其上的goroutine永遠無法執行。

　　另一種情況是P上的任務G很快就執行完了（分配不均），這個處理器P很忙，但是其他的P還有任務，此時如果global runqueue也沒有G了，那麼P就會從其他的P里拿一些G來執行。一般來說，如果一般就拿run queue的一半，這就確保了每個OS線程都能充分的使用。

　　golang採用了m:n線程模型，即m個gorountine（簡稱為G）映射到n個用戶態進程（簡稱為P）上，多個G對應一個P，一個P對應一個內核線程（簡稱為M）。

4.2 P、M的數量

　　P的數量：由啟動時環境變量$GOMAXPROCS或者是由runtime的方法GOMAXPROCS()決定（默認是1）。這意味着在程序執行的任意時刻都只有$GOMAXPROCS個goroutine在同時運行。在確定了P的最大數量n后，運行時系統會根據這個數量創建n個P。

 　　M的數量：go語言本身的限制：go程序啟動時，會設置M的最大數量，默認10000.但是內核很難支持這麼多的線程數，所以這個限制可以忽略。runtime/debug中的SetMaxThreads函數，設置M的最大數量。一個M阻塞了，會創建新的M。

　　M與P的數量沒有絕對關係，一個M阻塞，P就會去創建或者切換另一個M，所以，即使P的默認數量是1，也有可能會創建很多個M出來。

4.2 P、G的調度細節

　　P上G的調度：如果一個G不主動讓出cpu或被動block，所屬P中的其他G會一直等待順序執行。

　　一個G執行IO時可能會進入waiting狀態，主動讓出CPU，此時會被移到所屬P中的其他G後面，等待下一次輪到執行。 　　一個G調用了runtime.Gosched()會進入runnable狀態，主動讓出CPU，並被放到全局等待隊列中。 　　一個G調用了runtime.Goexit()，該G將會被立即終止，然後把已加載的defer（有點類似析構）依次執行完。 　　一個G調用了允許block的syscall，此時G及其對應的P、其他G和M都會被block起來，監控線程M會定時掃描所有P，一旦發現某個P處於block syscall狀態，則通知調度器讓另一個M來帶走P（這裏的另一個M可能是新創建的，因此隨着G被不斷block，M數量會不斷增加，最終M數量可能會超過P數量），這樣P及其餘下的G就不會被block了，等被block的M返回時發現自己的P沒有了，也就不能再處理G了，於是將G放入全局等待隊列等待空閑P接管，然後M自己sleep。 　　通過實驗，當一個G運行了很久（比如進入死循環），會被自動切到其他CPU核，可能是因為超過時間片后G被移到全局等待隊列中，後面被其他CPU核上的M處理。

　　M上P和G的調度：每當一個G要開始執行時，調度器判斷當前M的數量是否可以很好處理完G：如果M少G多且有空閑P，則新建M或喚醒一個sleep M，並指定使用某個空閑P；如果M應付得來，G被負載均衡放入一個現有P+M中。

　　當M處理完其身上的所有G后，會再去全局等待隊列中找G，如果沒有就從其他P中分一半的G（以便保證各個M處理G的負載大致相等），如果還沒有，M就去sleep了，對應的P變為空閑P。 在M進入sleep期間，調度器可能會給其P不斷放入G，等M醒后（比如超時）：如果G數量不多，則M直接處理這些G；如果M覺得G太多且有空閑P，會先主動喚醒其他sleep的M來分擔G，如果沒有其他sleep的M，調度器創建新M來分擔。

協程特點

　　協程擁有自己的寄存器上下文和棧。協程調度切換時，將寄存器上下文和棧保存到其他地方，在切回來的時候，恢復先前保存的寄存器上下文和棧。因此，協程能保留上一次調用時的狀態（即所有局部狀態的一個特定組合），每次過程重入時，就相當於進入上一次調用的狀態，換種說法：進入上一次離開時所處邏輯流的位置。線程和進程的操作是由程序觸發系統接口，最後的執行者是系統；協程的操作執行者則是用戶自身程序，goroutine也是協程。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

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

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

[FPGA]淺談LCD1602字符型液晶显示器(Verilog)

access_timePosted on by admin

概述

本文圍繞LCD1602字符型液晶显示器展開,並在FPGA開發板上用VerilogHDL語言實現模塊驅動.

首先來一張效果展示

那麼怎麼在這塊綠油油的平面上显示出點陣構成的字符呢?本文將為你提供一些思路.

注:本文僅討論寫入操作,實現在LCD1602上显示指定字符串,不講解讀取相關操作.

LCD1602

LCD1602是什麼?

LCD1602是一種字符型液晶显示模塊,不同於七段數碼管,它可以通過點陣的形式显示出各種圖案或字符,可拓展性較強.

其名稱中”LCD”即為 Liquid Crystal Display (液晶显示器),”1602″代表显示屏上可同時显示32個字符(16×2).

LCD1602的管腳

LCD1602共有16根管腳(部分型號只有14根,沒有背光管腳),管腳功能表如下

符號 管腳說明 符號 管腳說明
VSS 電源地 D2 數據
VDD 電源正極 D3 數據
VL 偏壓 D4 數據
RS 數據/命令選擇 D5 數據
R/W 讀/寫選擇 D6 數據
E 使能 D7 數據
D0 數據 BLA 背光正極
D1 數據 BLK 背光負極

其中需要我們關心的只有RS,E,和D0-D7.

RS_數據/命令選擇

RS端用來控制輸入給D0-D7的序列代表命令還是數據.

如果代表輸入命令,則輸入給D0-D7的序列相當於對模塊進行設置(下文會有輸入序列對應的指令表及其功能);如果代表輸入數據,則輸入給D0-D7的序列相當於寫入需要显示的字符串(輸入的是每個字符所對應的地址碼).

若RS為低電平,代表輸入命令;若RS為高電平,代表輸入數據.

E_使能

E端是用來執行命令的使能引腳,當它從高電平變成低電平時(下降沿),液晶模塊執行命令.

D0-D7

八位雙向并行數據線,在本文中僅作輸入端(寫入).

LCD1602有個DDRAM

DDRAM( Display Data Random Access Memory )即為显示數據隨機存取存儲器,相當於”顯存”,用來存放待显示的字符代碼.

DDRAM一共有80個字節,它和1602的显示屏上32個字符位的對應地址如下圖

第一行的16個字符位的地址對應0x00-0x0F,第二行則對應0x40-0x4F(“0x”代表16進制數).

LCD1602還有個CGROM

CGROM( Character Generator Read-Only Memory )即為字符產生只讀存儲器,用來存放192個常用字符的字模.

值得一提的是,表中的左半部分字符和他們的ASCII碼是對應的,所以在寫代碼時可以直接寫成”A”而不必要寫成”0x41″.

另外還有一個CGRAM用來存放用戶自定義的字符,可存放8個5×8字符或4個5×10字符,不過這不在本文討論範圍內.

指令集

前文已經提到,當RS為低電平時,代表輸入命令,那麼這些命令都有哪些呢?

將能實現某種功能的序列稱為一條命令,每條命令有幾個固定的位和幾個可變的位,可變的位可以改變功能/模式,將這些命令總稱為指令集.全體指令集如下錶

指令 RS R/W D7 D6 D5 D4 D3 D2 D1 D0
清屏 0 0 0 0 0 0 0 0 0 1
光標複位 0 0 0 0 0 0 0 0 0 x
進入模式設置 0 0 0 0 0 0 0 1 I/D S
显示開關設置 0 0 0 0 0 0 1 D C B
移位控制 0 0 0 0 0 1 S/C R/L x x
工作方式設置 0 0 0 0 1 DL N F x x
字符發生器地址設置 0 0 0 1 a a a a a a
數據存儲器地址設置 0 0 1 b b b b b b b
讀忙標誌或地址 0 1 BF c c c c c c c
寫入數據至CDRAM或DDRAM 1 0 d d d d d d d d
從CGRAM或DDRAM中讀取數據 1 1 e e e e e e e e

注:其中a代表字符發生存儲器地址,b代表显示數據存儲器地址,c代表計數器地址,d代表要寫入的數據內容,e代表讀取的數據內容.

我們關心的是其中的清屏,進入模式設置,显示開關設置,工作方式設置,數據存儲器地址設置.

清屏

清除屏幕显示內容,光標返回屏幕左上角.

執行這個指令時需要一定時間.

進入模式設置

I/D = 1:寫入新數據后光標右移,I/D = 0:寫入新數據后光標左移

S = 1:显示移動,S = 0:显示不移動.

显示開關設置

D = 1:显示功能開,D = 0,显示功能關(但是DDRAM中的數據依然保留).

C = 1:有光標,C = 0,沒有光標.

B = 1:光標閃爍,B = 0.光標不閃爍.

工作方式設置

DL = 1:8位數據接口(D7-D0),DL = 0:4位數據接口(D7-D4).

N = 0:一行显示,N = 1;兩行显示.

F = 0: 5×8點陣字符,F = 1: 5×10點陣字符.

數據存儲器地址設置

在對DDRAM進行讀寫之前,首先要設置DDRAM地址,然後才能進行讀寫.

地址設置見.

Verilog驅動

了解了1602的原理和功能后,就可以着手編寫驅動模塊了.想要讓LCD1602显示指定的字符,需要有一個驅動程序將模塊和用戶連接起來,實現輸入什麼就輸出什麼的功能,並能夠簡單的進行設置.

接下來開始寫驅動(造輪子).分為若干個次級模塊逐個分析.

模塊定義

模塊共有5個端口(其中8個數據端合為一個8位寬端口),分別為CLK時鐘輸入端,_RST低電平有效的複位端,LCD_E使能端,LCD_RS數據/命令選擇端,LCD_DATA數據端.

module LCD1602
(input CLK
,input _RST
,output LCD_E 
,output reg LCD_RS
,output reg[7:0]LCD_DATA
);

上電穩定

這是一個簡單的初始化模塊,數據手冊要求要先通電20ms才可以進行下一步操作,為了使之上電穩定.

parameter TIME_20MS=1_000_000;//需要20ms以達上電穩定(初始化)
reg[19:0]cnt_20ms;
always@(posedge CLK or negedge _RST)
    if(!_RST)
        cnt_20ms<=1'b0;
    else if(cnt_20ms==TIME_20MS-1'b1)
        cnt_20ms<=cnt_20ms;
    else
        cnt_20ms<=cnt_20ms+1'b1 ;

wire delay_done=(cnt_20ms==TIME_20MS-1'b1)?1'b1:1'b0;//上電延時完畢

工作周期分頻

LCD1602的工作周期為500Hz,所以要進行分頻(板載晶振為50MHz).

parameter TIME_500HZ=100_000;//工作周期
reg[19:0]cnt_500hz;
always@(posedge CLK or negedge _RST)
    if(!_RST)
        cnt_500hz<=1'b0;
    else if(delay_done)
        if(cnt_500hz==TIME_500HZ-1'b1)
            cnt_500hz<=1'b0;
        else
            cnt_500hz<=cnt_500hz+1'b1;
    else
        cnt_500hz<=1'b0;

assign LCD_E=(cnt_500hz>(TIME_500HZ-1'b1)/2)?1'b0:1'b1;//使能端,每個工作周期一次下降沿,執行一次命令
wire write_flag=(cnt_500hz==TIME_500HZ-1'b1)?1'b1:1'b0;//每到一個工作周期,write_flag置高一周期

狀態機

模塊工作採用狀態機驅動.

//狀態機有40種狀態,此處用了格雷碼,一次只有一位變化(在二進制下)
parameter IDLE=8'h00;
parameter SET_FUNCTION=8'h01;
parameter DISP_OFF=8'h03;
parameter DISP_CLEAR=8'h02;
parameter ENTRY_MODE=8'h06;
parameter DISP_ON=8'h07;
parameter ROW1_ADDR=8'h05;
parameter ROW1_0=8'h04;
parameter ROW1_1=8'h0C;
parameter ROW1_2=8'h0D;
parameter ROW1_3=8'h0F;
parameter ROW1_4=8'h0E;
parameter ROW1_5=8'h0A;
parameter ROW1_6=8'h0B;
parameter ROW1_7=8'h09;
parameter ROW1_8=8'h08;
parameter ROW1_9=8'h18;
parameter ROW1_A=8'h19;
parameter ROW1_B=8'h1B;
parameter ROW1_C=8'h1A;
parameter ROW1_D=8'h1E;
parameter ROW1_E=8'h1F;
parameter ROW1_F=8'h1D;
parameter ROW2_ADDR=8'h1C;
parameter ROW2_0=8'h14;
parameter ROW2_1=8'h15;
parameter ROW2_2=8'h17;
parameter ROW2_3=8'h16;
parameter ROW2_4=8'h12;
parameter ROW2_5=8'h13;
parameter ROW2_6=8'h11;
parameter ROW2_7=8'h10;
parameter ROW2_8=8'h30;
parameter ROW2_9=8'h31;
parameter ROW2_A=8'h33;
parameter ROW2_B=8'h32;
parameter ROW2_C=8'h36;
parameter ROW2_D=8'h37;
parameter ROW2_E=8'h35;
parameter ROW2_F=8'h34;

reg[5:0]c_state;//Current state,當前狀態
reg[5:0]n_state;//Next state,下一狀態

always@(posedge CLK or negedge _RST)
    if(!_RST)
        c_state<=IDLE;
    else if(write_flag)//每一個工作周期改變一次狀態
        c_state<=n_state;
    else
        c_state<=c_state;

always@(*)
    case (c_state)
        IDLE:n_state=SET_FUNCTION;
        SET_FUNCTION:n_state=DISP_OFF;
        DISP_OFF:n_state=DISP_CLEAR;
        DISP_CLEAR:n_state=ENTRY_MODE;
        ENTRY_MODE:n_state=DISP_ON;
        DISP_ON:n_state=ROW1_ADDR;
        ROW1_ADDR:n_state=ROW1_0;
        ROW1_0:n_state=ROW1_1;
        ROW1_1:n_state=ROW1_2;
        ROW1_2:n_state=ROW1_3;
        ROW1_3:n_state=ROW1_4;
        ROW1_4:n_state=ROW1_5;
        ROW1_5:n_state=ROW1_6;
        ROW1_6:n_state=ROW1_7;
        ROW1_7:n_state=ROW1_8;
        ROW1_8:n_state=ROW1_9;
        ROW1_9:n_state=ROW1_A;
        ROW1_A:n_state=ROW1_B;
        ROW1_B:n_state=ROW1_C;
        ROW1_C:n_state=ROW1_D;
        ROW1_D:n_state=ROW1_E;
        ROW1_E:n_state=ROW1_F;
        ROW1_F:n_state=ROW2_ADDR;
        ROW2_ADDR:n_state=ROW2_0;
        ROW2_0:n_state=ROW2_1;
        ROW2_1:n_state=ROW2_2;
        ROW2_2:n_state=ROW2_3;
        ROW2_3:n_state=ROW2_4;
        ROW2_4:n_state=ROW2_5;
        ROW2_5:n_state=ROW2_6;
        ROW2_6:n_state=ROW2_7;
        ROW2_7:n_state=ROW2_8;
        ROW2_8:n_state=ROW2_9;
        ROW2_9:n_state=ROW2_A;
        ROW2_A:n_state=ROW2_B;
        ROW2_B:n_state=ROW2_C;
        ROW2_C:n_state=ROW2_D;
        ROW2_D:n_state=ROW2_E;
        ROW2_E:n_state=ROW2_F;
        ROW2_F:n_state=ROW1_ADDR;//循環到1-1進行掃描显示
        default:;
    endcase

RS端控制

控制輸入為數據或命令

always@(posedge CLK or negedge _RST)
    if(!_RST)
        LCD_RS<=1'b0;//為0時輸入指令,為1時輸入數據
    else if(write_flag)
        //當狀態為七個指令任意一個,將RS置為指令輸入狀態
        if((n_state==SET_FUNCTION)||(n_state==DISP_OFF)||(n_state==DISP_CLEAR)||(n_state==ENTRY_MODE)||(n_state==DISP_ON)||(n_state==ROW1_ADDR)||(n_state==ROW2_ADDR))
            LCD_RS<=1'b0; 
        else
            LCD_RS<=1'b1;
    else
        LCD_RS<=LCD_RS;

显示控制

always@(posedge CLK or negedge _RST)
    if(!_RST)
        LCD_DATA<=1'b0;
    else if(write_flag)
        case(n_state)
            IDLE:LCD_DATA<=8'hxx;
            SET_FUNCTION:LCD_DATA<=8'h38;//8'b0011_1000,工作方式設置:DL=1(DB4,8位數據接口),N=1(DB3,兩行显示),L=0(DB2,5x8點陣显示).
            DISP_OFF:LCD_DATA<=8'h08;//8'b0000_1000,显示開關設置:D=0(DB2,显示關),C=0(DB1,光標不显示),D=0(DB0,光標不閃爍)
            DISP_CLEAR:LCD_DATA<=8'h01;//8'b0000_0001,清屏
            ENTRY_MODE:LCD_DATA<=8'h06;//8'b0000_0110,進入模式設置:I/D=1(DB1,寫入新數據光標右移),S=0(DB0,显示不移動)
            DISP_ON:LCD_DATA<=8'h0c;//8'b0000_1100,显示開關設置:D=1(DB2,显示開),C=0(DB1,光標不显示),D=0(DB0,光標不閃爍)
            ROW1_ADDR:LCD_DATA<=8'h80;//8'b1000_0000,設置DDRAM地址:00H->1-1,第一行第一位
            //將輸入的row_1以每8-bit拆分,分配給對應的显示位
            ROW1_0:LCD_DATA<=row_1[127:120];
            ROW1_1:LCD_DATA<=row_1[119:112];
            ROW1_2:LCD_DATA<=row_1[111:104];
            ROW1_3:LCD_DATA<=row_1[103: 96];
            ROW1_4:LCD_DATA<=row_1[ 95: 88];
            ROW1_5:LCD_DATA<=row_1[ 87: 80];
            ROW1_6:LCD_DATA<=row_1[ 79: 72];
            ROW1_7:LCD_DATA<=row_1[ 71: 64];
            ROW1_8:LCD_DATA<=row_1[ 63: 56];
            ROW1_9:LCD_DATA<=row_1[ 55: 48];
            ROW1_A:LCD_DATA<=row_1[ 47: 40];
            ROW1_B:LCD_DATA<=row_1[ 39: 32];
            ROW1_C:LCD_DATA<=row_1[ 31: 24];
            ROW1_D:LCD_DATA<=row_1[ 23: 16];
            ROW1_E:LCD_DATA<=row_1[ 15:  8];
            ROW1_F:LCD_DATA<=row_1[  7:  0];
            ROW2_ADDR:LCD_DATA<=8'hc0;//8'b1100_0000,設置DDRAM地址:40H->2-1,第二行第一位
            ROW2_0:LCD_DATA<=row_2[127:120];
            ROW2_1:LCD_DATA<=row_2[119:112];
            ROW2_2:LCD_DATA<=row_2[111:104];
            ROW2_3:LCD_DATA<=row_2[103: 96];
            ROW2_4:LCD_DATA<=row_2[ 95: 88];
            ROW2_5:LCD_DATA<=row_2[ 87: 80];
            ROW2_6:LCD_DATA<=row_2[ 79: 72];
            ROW2_7:LCD_DATA<=row_2[ 71: 64];
            ROW2_8:LCD_DATA<=row_2[ 63: 56];
            ROW2_9:LCD_DATA<=row_2[ 55: 48];
            ROW2_A:LCD_DATA<=row_2[ 47: 40];
            ROW2_B:LCD_DATA<=row_2[ 39: 32];
            ROW2_C:LCD_DATA<=row_2[ 31: 24];
            ROW2_D:LCD_DATA<=row_2[ 23: 16];
            ROW2_E:LCD_DATA<=row_2[ 15:  8];
            ROW2_F:LCD_DATA<=row_2[  7:  0];
        endcase
    else
        LCD_DATA<=LCD_DATA;

自定義字符輸入

輸入要显示的字符.

wire[127:0]row_1;
wire[127:0]row_2;
assign row_1 ="   Welcome to   ";//第一行显示的內容(16個字符)
assign row_2 ="    My Blog!    ";//第二行显示的內容(16個字符)

效果展示

將以上代碼有機整合后,燒錄至開發板上,按下複位鍵即可看到显示屏上显示出了指定字樣.

你可以修改字符串來讓屏幕显示出不同的內容,甚至可以調整模式讓显示屏滾動显示大於16字符的字符串.

總結

LCD1602是一個很基礎的模塊,把這個掌握后對以後的學習幫助很大,所以很有必要學習.

這個模塊不止可以通過Verilog驅動,也可以用其他語言或其他開發板來實現,例如STM32,51單片機或者SV,VHDL語言,都可以寫一套讓他工作的驅動.

另外,如果有現成的輪子,為什麼還要自己造一個出來呢?在碰到類似情況時可以藉助互聯網參考一下別人對此問題有怎麼樣的解決方案,加以借鑒並內化於心,才能達到最高效率的學習.

參考資料

[1] aslmer. “verilog寫的LCD1602 显示”[ED/OL]. https://www.cnblogs.com/aslmer/p/5819422.html ,2016(8).

[2] aslmer. “LCD1602指令集解讀”[ED/OL]. https://www.cnblogs.com/aslmer/p/5801363.html ,2016(8).

[3] 阿忠ZHONG. “單片機显示原理(LCD1602)”[ED/OL]. https://www.cnblogs.com/hui088/p/4732034.html 2015(8).

[4] 百度百科. “詞條-LCD1602″[ED/OL]. https://baike.baidu.com/item/LCD1602/6014393 ,2019(9).

[5] HITACHI©Ltd. “HD44780U (LCD-II)(Dot Matrix Liquid Crystal Display Controller/Driver)”[M]. Japan HITACHI,1998.

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

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

※想要讓你的商品在網路上成為最夯、最多人討論的話題?

※高價收購3C產品,價格不怕你比較

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

Redis 4.0鮮為人知的功能將加速您的應用程序

access_timePosted on by admin

來源：Redislabs

作者：Kyle Davis

翻譯：Kevin (公眾號：中間件小哥）

Redis 4.0給Redis生態帶來了一個驚人的功能：Modules（模塊）。Modules是Redis的一大轉變，它是Redis內部自定義數據類型和全速計算的開放環境。但是，儘管對該版本的大多數關注都集中在Modules上，但新版本還引入了一個非常重要的命令，它就是遊戲規則的改變者：UNLINK。

您可以使用redis-cli連接redis-server執行info命令，去查看當前redis版本中是否可以使用UNLINK命令。info響應將告訴您有關服務器的所有信息。在第一部分（#Server）中，返回結果有一行值為redis_version。如果該值大於4.0，則可以使用UNLINK命令。並非所有Redis提供商都保持最新版本，因此最好在更改代碼之前檢查redis版本。

讓我們回顧一下Redis的關鍵架構功能之一：“單線程”。Redis在大多數情況下是一個單線程應用程序。它一次只做一件事，這樣可以把這些事做的更快。多線程有點複雜，並且引入了鎖和其他可能降低應用程序速度的問題。儘管Redis（最高4.0版）通過多線程方式執行了少量操作，但它通常在啟動另一個命令之前先要完成一個命令。

相比於快速讀寫，您可能會覺得使用DEL命令去刪除一個鍵值不需要考慮太多，但是在很多情況下，刪除數據同樣很重要。與Redis中的大多數命令一樣，DEL命令在單個線程中運行，如果您獲取一個幾千字節的鍵值，花費不到一毫秒的時間，這是您所感知不到的。然而，當您獲取的鍵值大小是兆字節、100兆字節或者500兆字節會發生什麼呢？哈希、排序、列表等數據結構會隨着時間的推移而添加更多的數據進去，這樣會生成一個數GB大小的數據集。然後用DEL命令去刪除大Key時會發生什麼呢？由於Redis是單線程操作的，處理這種請求時整個服務都處於等待中，需要等待該命令執行完成才能執行其它操作。同時，我們考慮更複雜的一種場景，這些鍵中保存的數據可能已經包含數以千萬個微小請求，因此應用程序或操作員可能無法真正了解刪除這些數據需要花費多長時間。

理智會告訴我們不要在擁有100萬元素的排序集上運行如下這樣的命令：

> ZRANGE some-zset 0 -1

但是，在上面的some-zset集合中執行DEL命令將花費和上面一樣的時間-中間沒有傳輸開銷，但是它會一直去分配內存，而且您會一直卡死在CPU繁忙中。在使用UNLINK之前，您可能會結合SCAN命令採用非原子性的方法進行一些少量刪除，去避免這種持續分配內存的噩夢。上面無論使用哪種方式，都是讓人無法接受的。

您可能已經猜到了，就是使用UNLINK命令來替換DEL！從語法上講，UNLINK與DEL相同，但UNLINK提供了更為理想的解決方案。首先，它將鍵值從整個鍵值空間中刪除。然後，在另一個線程中，它開始回收內存。從多線程的角度來看，這是一種安全的操作，因為它（在主線程中）從鍵空間中刪除了該項，從而使Redis其它命令無法訪問。

如果你有一個快速增長的鍵值-不管鍵值的大小如何，UNLINK都是O（1）操作（每個鍵；在主線程中）。使用DEL刪除一個大值可能需要幾百毫秒或更長時間，而UNLINK將在不到一毫秒的時間內完成（包括網絡往返）。當然，您的服務器仍將需要花一些時間在另一個線程中重新分配該值的內存（其中的工作是O（N），其中N是已刪除值的分配數），但是主線程的性能不會被另一個線程中正在進行的操作嚴重影響到。

因此，您是否應該用UNLINK命令替換代碼中的所有DEL命令？當然，在少數情況下，DEL正是您所需要的。這裏我可以想到兩點：

1、   在MULTI / EXEC或pipeline中，在添加和刪除大值時DEL命令是一種理想選擇。在這種情況下，UNLINK不會立即釋放空間，並且在處理繁忙的情況下（如果內存已滿），您可能會遇到麻煩。

2、   在更緊急的情況下，在無快速響應驅逐數據下您可以寫入數據。

在沒有極端內存限制的理想環境中，很難想到不使用UNLINK的情況。UNLINK將提供更一致的行為，總體上具有更好的性能，並且代碼更改非常小（如果可以在客戶端中重命名命令，則無需更改）。如果UNLINK適合您的應用程序，請就此將您的DEL更改為UNLINK，然後查看它的性能提高。

 

更多優質中間件技術資訊/原創/翻譯文章/資料/乾貨，請關注“中間件小哥”公眾號！

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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

Java 數據持久化系列之JDBC

access_timePosted on by admin

前段時間小冰在工作中遇到了一系列關於數據持久化的問題，在排查問題時發現自己對 Java 後端的數據持久化框架的原理都不太了解，只有不斷試錯，因此走了很多彎路。於是下定決心，集中精力學習了持久化相關框架的原理和實現，總結出這個系列。

上圖是我根據相關源碼和網上資料總結的有關 Java 數據持久化的架構圖(只代表本人想法，如有問題，歡迎留言指出)。最下層就是今天要講的 JDBC，上一層是數據庫連接池層，包括 HikariCP 和 Druid等；再上一層是分庫分表中間件，比如說 ShardingJDBC；再向上是對象關係映射層，也就是 ORM，包括 Mybatis 和 JPA；最上邊是 Spring 的事務管理。

本系列的文章會依次講解圖中各個開源框架的基礎使用，然後描述其原理和代碼實現，最後會着重分析它們之間是如何相互集成和配合的。

廢話不多說，我們先來看 JDBC。

JDBC 定義

JDBC是Java Database Connectivity的簡稱，它定義了一套訪問數據庫的規範和接口。但它自身不參与數據庫訪問的實現。因此對於目前存在的數據庫（譬如Mysql、Oracle）來說，要麼數據庫製造商本身提供這些規範與接口的實現，要麼社區提供這些實現。

如上圖所示，Java 程序只依賴於 JDBC API，通過 DriverManager 來獲取驅動，並且針對不同的數據庫可以使用不同的驅動。這是典型的橋接的設計模式，把抽象 Abstraction 與行為實現Implementation 分離開來，從而可以保持各部分的獨立性以及應對他們的功能擴展。

JDBC 基礎代碼示例

單純使用 JDBC 的代碼邏輯十分簡單，我們就以最為常用的MySQL 為例，展示一下使用 JDBC 來建立數據庫連接、執行查詢語句和遍歷結果的過程。

public static void connectionTest(){

    Connection connection = null;
    Statement statement = null;
    ResultSet resultSet = null;

    try {
        // 1. 加載並註冊 MySQL 的驅動
        Class.forName("com.mysql.cj.jdbc.Driver").newInstance();

        // 2. 根據特定的數據庫連接URL，返回與此URL的所匹配的數據庫驅動對象
        Driver driver = DriverManager.getDriver(URL);
        // 3. 傳入參數，比如說用戶名和密碼
        Properties props = new Properties();
        props.put("user", USER_NAME);
        props.put("password", PASSWORD);

        // 4. 使用數據庫驅動創建數據庫連接 Connection
        connection = driver.connect(URL, props);

        // 5. 從數據庫連接 connection 中獲得 Statement 對象
        statement = connection.createStatement();
        // 6. 執行 sql 語句，返回結果
        resultSet = statement.executeQuery("select * from activity");
        // 7. 處理結果，取出數據
        while(resultSet.next())
        {
            System.out.println(resultSet.getString(2));
        }

        .....
    }finally{
        // 8.關閉鏈接，釋放資源  按照JDBC的規範，使用完成后管理鏈接，
        // 釋放資源，釋放順序應該是： ResultSet ->Statement ->Connection
        resultSet.close();
        statement.close();
        connection.close();
    }
}

代碼中有詳細的註釋描述每一步的過程，相信大家也都對這段代碼十分熟悉。

唯一要提醒的是使用完之後的資源釋放順序。按照 JDBC 規範，應該依次釋放 ResultSet，Statement 和 Connection。當然這隻是規範，很多開源框架都沒有嚴格的執行，但是 HikariCP卻嚴格准守了，它可以帶來很多優勢，這些會在之後的文章中講解。

上圖是 JDBC 中核心的 5 個類或者接口的關係，它們分別是 DriverManager、Driver、Connection、Statement 和 ResultSet。

DriverManager 負責管理數據庫驅動程序，根據 URL 獲取與之匹配的 Driver 具體實現。Driver 則負責處理與具體數據庫的通信細節，根據 URL 創建數據庫連接 Connection。

Connection 表示與數據庫的一個連接會話，可以和數據庫進行數據交互。Statement 是需要執行的 SQL 語句或者存儲過程語句對應的實體，可以執行對應的 SQL 語句。ResultSet 則是 Statement 執行后獲得的結果集對象，可以使用迭代器從中遍曆數據。

不同數據庫的驅動都會實現各自的 Driver、Connection、Statement 和 ResultSet。而更為重要的是，眾多數據庫連接池和分庫分表框架也都是實現了自己的 Connection、Statement 和 ResultSet，比如說 HikariCP、Druid 和 ShardingJDBC。我們接下來會經常看到它們的身影。

接下來，我們依次看一下這幾個類及其涉及的操作的原理和源碼實現。

載入 Driver 實現

可以直接使用 Class#forName的方式來載入驅動實現，或者在 JDBC 4.0 后則基於 SPI 機制來導入驅動實現，通過在 META-INF/services/java.sql.Driver 文件中指定實現類的方式來導入驅動實現，下面我們就來看一下兩種方式的實現原理。

Class#forName 作用是要求 JVM 查找並加載指定的類，如果在類中有靜態初始化器的話，JVM 會執行該類的靜態代碼段。加載具體 Driver 實現時，就會執行 Driver 中的靜態代碼段，將該 Driver 實現註冊到 DriverManager 中。我們來看一下 MySQL 對應 Driver 的具體代碼。它就是直接調用了 DriverManager的 registerDriver 方法將自己註冊到其維護的驅動列表中。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        // 直接調用 DriverManager的 registerDriver 將自己註冊到其中
        DriverManager.registerDriver(new Driver());
    }
}

SPI 機制使用 ServiceLoader 類來提供服務發現機制，動態地為某個接口尋找服務實現。當服務的提供者提供了服務接口的一種實現之後，必須根據 SPI 約定在 META-INF/services 目錄下創建一個以服務接口命名的文件，在該文件中寫入實現該服務接口的具體實現類。當服務調用 ServiceLoader 的 load 方法的時候，ServiceLoader 能夠通過約定的目錄找到指定的文件，並裝載實例化，完成服務的發現。

DriverManager 中的 loadInitialDrivers 方法會使用 ServiceLoader 的 load 方法加載目前項目路徑下的所有 Driver 實現。

public class DriverManager {
    // 程序中已經註冊的Driver具體實現信息列表。registerDriver類就是將Driver加入到這個列表
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    // 使用ServiceLoader 加載具體的jdbc driver實現
    static {
        loadInitialDrivers();
    }
    private static void loadInitialDrivers() {
        // 省略了異常處理
        // 獲得系統屬性 jdbc.drivers 配置的值
        String drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });

        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {

                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                // 通過 ServiceLoader 獲取到Driver的具體實現類，然後加載這些類，會調用其靜態代碼塊
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
                return null;
            }
        });

        String[] driversList = drivers.split(":");
        // for 循環加載系統屬性中的Driver類。
        for (String aDriver : driversList) {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        }
    }
}

比如說，項目引用了 MySQL 的 jar包 mysql-connector-java，在這個 jar 包的 META-INF/services 文件夾下有一個叫 java.sql.Driver 的文件，文件的內容為 com.mysql.cj.jdbc.Driver。而 ServiceLoader 的 load 方法找到這個文件夾下的文件，讀取文件的內容，然後加載出文件內容所指定的 Driver 實現。而正如之前所分析的，這個 Driver 類被加載時，會調用 DriverManager 的 registerDriver 方法，從而完成了驅動的加載。

Connection、Statement 和 ResultSet

當程序加載完具體驅動實現后，接下來就是建立與數據庫的連接，執行 SQL 語句並且處理返回結果了，其過程如下圖所示。

建立 Connection

創建 Connection 連接對象，可以使用 Driver 的 connect 方法，也可以使用 DriverManager 提供的 getConnection 方法，此方法通過 url 自動匹配對應的驅動 Driver 實例，然後還是調用對應的 connect 方法返回 Connection 對象實例。

建立 Connection 會涉及到與數據庫進行網絡請求等大量費時的操作，為了提升性能，往往都會引入數據庫連接池，也就是說復用 Connection，免去每次都創建 Connection 所消耗的時間和系統資源。

Connection 默認情況下，對於創建的 Statement 執行的 SQL 語句都是自動提交事務的，即在 Statement 語句執行完后，自動執行 commit 操作，將事務提交，結果影響到物理數據庫。為了滿足更好地事務控制需求，我們也可以手動地控制事務，手動地在Statement 的 SQL 語句執行後進行 commit 或者rollback。

connection = driver.connect(URL, props);
// 將自動提交關閉
connection.setAutoCommit(false);

statement = connection.createStatement();
statement.execute("INSERT INTO activity (activity_id, activity_name, product_id, start_time, end_time, total, status, sec_speed, buy_limit, buy_rate) VALUES (1, '香蕉大甩賣', 1, 530871061, 530872061, 20, 0, 1, 1, 0.20);");
// 執行後手動 commit
statement.getConnection().commit();

Statement

Statement 的功能在於根據傳入的 SQL 語句，將傳入 SQL 經過整理組合成數據庫能夠識別的執行語句(對於靜態的 SQL 語句，不需要整理組合；而對於預編譯SQL 語句和批量語句，則需要整理)，然後傳遞 SQL 請求，之後會得到返回的結果。對於查詢 SQL，結果會以 ResultSet 的形式返回。

當你創建了一個 Statement 對象之後，你可以用它的三個執行方法的任一方法來執行 SQL 語句。

  • boolean execute(String SQL) : 如果 ResultSet 對象可以被檢索，則返回的布爾值為 true ，否則返回 false 。當你需要使用真正的動態 SQL 時，可以使用這個方法來執行 SQL DDL 語句。
  • int executeUpdate(String SQL) : 返回執行 SQL 語句影響的行的數目。使用該方法來執行 SQL 語句，是希望得到一些受影響的行的數目，例如，INSERT，UPDATE 或 DELETE 語句。
  • ResultSet executeQuery(String SQL) : 返回一個 ResultSet 對象。當你希望得到一個結果集時使用該方法，就像你使用一個 SELECT 語句。

對於不同類型的 SQL 語句，Statement 有不同的接口與其對應。

接口 | 介紹
-|-| Statement | 適合運行靜態 SQL 語句，不接受動態參數 PreparedStatement | 計劃多次使用並且預先編譯的 SQL 語句，接口需要傳入額外的參數 CallableStatement | 用於訪問數據庫存儲過程

Statement 主要用於執行靜態SQL語句，即內容固定不變的SQL語句。Statement每執行一次都要對傳入的SQL語句編譯一次，效率較差。而 PreparedStatement則解決了這個問題，它會對 SQL 進行預編譯，提高了執行效率。

PreparedStatement pstmt = null;
    try {
        String SQL = "Update activity SET activity_name = ? WHERE activity_id = ?";
        pstmt = connection.prepareStatement(SQL);
        pstmt.setString(1, "測試");
        pstmt.setInt(2, 1);
        pstmt.executeUpdate();
    }
    catch (SQLException e) {
    }
    finally {
        pstmt.close();
    }
}

除此之外， PreparedStatement 還可以預防 SQL 注入，因為 PreparedStatement 不允許在插入參數時改變 SQL 語句的邏輯結構。

PreparedStatement 傳入任何數據不會和原 SQL 語句發生匹配關係，無需對輸入的數據做過濾。如果用戶將”or 1 = 1”傳入賦值給佔位符，下述SQL 語句將無法執行：select * from t where username = ? and password = ?。

ResultSet

當 Statement 查詢 SQL 執行后，會得到 ResultSet 對象，ResultSet 對象是 SQL語句查詢的結果集合。ResultSet 對從數據庫返回的結果進行了封裝，使用迭代器的模式可以逐條取出結果集中的記錄。

while(resultSet.next()) {
    System.out.println(resultSet.getString(2));
}

ResultSet 一般也建議使用完畢直接 close 掉，但是需要注意的是關閉 ResultSet 對象不關閉其持有的 Blob、Clob 或 NClob 對象。 Blob、Clob 或 NClob 對象在它們被創建的的事務期間會一直持有效，除非其 free 函數被調用。

參考

    • https://blog.csdn.net/wl044090432/article/details/60768342
    • https://blog.csdn.net/luanlouis/article/details/29850811

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

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

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

http協議詳細介紹

access_timePosted on by admin

1.1 HTTP協議簡介
我們日常生活中經常會使用瀏覽器訪問Web站點，但是大家有思考過在這個過程中到底發生了什麼嗎？為什麼我們在瀏覽器地址欄上面輸入要訪問的URL后就可以訪問到Web頁面呢？

1.1.1 瀏覽器背後的故事
當我們在瀏覽器地址欄上輸入要訪問的URL后，瀏覽器會分析出URL上面的域名，然後通過DNS服務器查詢出域名映射的IP地址，瀏覽器根據查詢到的IP地址與Web服務器進行通信，而通信的協議就是HTTP協議。

我們可以把這個過程類比成一個電話對話的過程。當我們要打電話給某個人，首先要知道對方的電話號碼，然後進行撥號。打通電話后我們會進行對話，當然要對話肯定需要共同的語言，如果一個人說國語，而另一個人說英語，那肯定不能進行溝通的。在本例中，電話號碼相當於上面的IP地址，而共同語言相當於HTTP協議。

我們通過一個簡單的圖來闡述這個過程：

瀏覽器與Web服務器使用HTTP協議進行通信，那麼什麼是HTTP協議呢？接下來我們會詳細介紹HTTP協議的相關知識。

1.1.2 TCP/IP協議
HTTP協議是構建在TCP/IP協議之上的，是TCP/IP協議的一個子集，所以要理解HTTP協議，有必要先了解下TCP/IP協議相關的知識。

由於TCP/IP協議族包含眾多的協議，在這裏我們無法一一討論。接下來，我們僅介紹理解HTTP協議需要掌握的TCP/IP協議族的一些相關知識點。如果想深入理解TCP/IP協議，可以參考經典書籍《TCP/IP詳解》。

TCP/IP協議族分層

TCP/IP協議族是由一個四層協議組成的系統，這四層分別為：應用層、傳輸層、網絡層和數據鏈路層。如圖所示

分層的好處是把各個相對獨立的功能解耦，層與層之間通過規定好的接口來通信。如果以後需要修改或者重寫某一個層的實現，只要接口保持不變也不會影響到其他層的功能。接下來，我們將會介紹各個層的主要作用。

1) 應用層

應用層一般是我們編寫的應用程序，其決定了向用戶提供的應用服務。應用層可以通過系統調用與傳輸層進行通信。

處於應用層的協議非常多，比如：FTP（File Transfer Protocol，文件傳輸協議）、DNS（Domain Name System，域名系統）和我們本章討論的HTTP（HyperText Transfer Protocol，超文本傳輸協議）等。

2) 傳輸層

傳輸層通過系統調用嚮應用層提供處於網絡連接中的兩台計算機之間的數據傳輸功能。

在傳輸層有兩個性質不同的協議：TCP（Transmission Control Protocol，傳輸控制協議）和UDP（User Data Protocol，用戶數據報協議）。

3) 網絡層

網絡層用來處理在網絡上流動的數據包，數據包是網絡傳輸的最小數據單位。該層規定了通過怎樣的路徑（傳輸路線）到達對方計算機，並把數據包傳輸給對方。

4) 鏈路層

鏈路層用來處理連接網絡的硬件部分，包括控制操作系統、硬件設備驅動、NIC（Network Interface Card，網絡適配器）以及光纖等物理可見部分。硬件上的範疇均在鏈路層的作用範圍之內。

數據包封裝

上層協議數據是如何轉變為下層協議數據的呢？這是通過封裝（encapsulate）來實現的。應用程序數據在發送到物理網絡之前，會沿着協議棧從上往下傳遞。每層協議都將在上層協議數據的基礎上加上自己的頭部信息（鏈路層還會加上尾部信息），以為實現該層功能提供必要的信息。如圖所示：

發送端發送數據時，數據會從上層傳輸到下層，且每經過一層都會被打上該層的頭部信息。而接收端接收數據時，數據會從下層傳輸到上層，傳輸前會把下層的頭部信息刪除。過程如圖所示：

數據傳輸過程

由於下層協議的頭部信息對上層協議是沒有實際的用途，所以在下層協議傳輸數據給上層協議的時候會把該層的頭部信息去掉，這個封裝過程對於上層協議來說是完全透明的。這樣做的好處是，應用層只需要關心應用服務的實現，而不用管底層的實現。

TCP三次握手

從上面的介紹可知，傳輸層協議主要有兩個：TCP協議和UDP協議。TCP協議相對於UDP協議的特點是：TCP協議提供面向連接、字節流和可靠的傳輸。

使用TCP協議進行通信的雙方必須先建立連接，然後才能開始傳輸數據。TCP連接是全雙工的，也就是說雙方的數據讀寫可以通過一個連接進行。為了確保連接雙方可靠性，在雙方建立連接時，TCP協議採用了三次握手（Three-way handshaking）策略。
過程如圖所示：

TCP協議三次握手的描述如下：

第一次握手：客戶端發送帶有SYN標誌的連接請求報文段，然後進入SYN_SEND狀態，等待服務端的確認。

第二次握手：服務端接收到客戶端的SYN報文段后，需要發送ACK信息對這個SYN報文段進行確認。同時，還要發送自己的SYN請求信息。服務端會將上述的信息放到一個報文段（SYN+ACK報文段）中，一併發送給客戶端，此時服務端將會進入SYN_RECV狀態。

第三次握手：客戶端接收到服務端的SYN+ACK報文段后，會想服務端發送ACK確認報文段，這個報文段發送完畢后，客戶端和服務端都進入ESTABLISHED狀態，完成TCP三次握手。

當三次握手完成后，TCP協議會為連接雙方維持連接狀態。為了保證數據傳輸成功，接收端在接收到數據包后必須發送ACK報文作為確認。如果在指定的時間內（這個時間稱為重新發送超時時間），發送端沒有接收到接收端的ACK報文，那麼就會重發超時的數據。

1.1.3 DNS服務
前面介紹了與HTTP協議有着密切關係的TCP/IP協議，接下來介紹的DNS服務也是與HTTP協議有着密不可分的關係。

通常我們訪問一個網站，使用的是主機名或者域名來進行訪問的。因為相對於IP地址（一組純数字），域名更容易讓人記住。但TCP/IP協議使用的是IP地址進行訪問的，所以必須有個機制或服務把域名轉換成IP地址。DNS服務就是用來解決這個問題的，它提供域名到IP地址之間的解析服務。

如下圖所示，展示了DNS服務把域名解析成IP地址的過程：

DNS服務是通過DNS協議進行通信的，而DNS協議跟HTTP協議一樣也是應用層協議。由於我們的重點是HTTP協議，所以這裏不打算對DNS協議進行詳細的分析，我們只需要知道可以通過DNS服務把域名解析成IP地址即可。

1.1.4 HTTP與TCP/IP、DNS的關係
到現在，我們介紹了與HTTP協議有密切關係的TCP/IP協議和DNS服務，接下來我們通過下圖來整理一下HTTP協議與它們之間的關係：

HTTP與TCP/IP、DNS的關係
從上圖中可以知道，當客戶端訪問Web站點時，首先會通過DNS服務查詢到域名的IP地址。然後瀏覽器生成HTTP請求，並通過TCP/IP協議發送給Web服務器。Web服務器接收到請求後會根據請求生成響應內容，並通過TCP/IP協議返回給客戶端。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

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

※想要讓你的商品在網路上成為最夯、最多人討論的話題?

※高價收購3C產品,價格不怕你比較

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

高併發編程學習(1)——併發基礎

access_timePosted on by admin

為更良好的閱讀體驗，請訪問原文：

一、前言

當我們使用計算機時，可以同時做許多事情，例如一邊打遊戲一邊聽音樂。這是因為操作系統支持併發任務，從而使得這些工作得以同時進行。

  • 那麼提出一個問題：如果我們要實現一個程序能一邊聽音樂一邊玩遊戲怎麼實現呢？
public class Tester {

    public static void main(String[] args) {
        System.out.println("開始....");
        playGame();
        playMusic();
        System.out.println("結束....");
    }

    private static void playGame() {
        for (int i = 0; i < 50; i++) {
            System.out.println("玩遊戲" + i);
        }
    }

    private static void playMusic() {
        for (int i = 0; i < 50; i++) {
            System.out.println("播放音樂" + i);
        }
    }
}

我們使用了循環來模擬過程，因為播放音樂和打遊戲都是連續的，但是結果卻不盡人意，因為函數體總是要執行完之後才能返回。那麼到底怎麼解決這個問題？

并行與併發

并行性和併發性是既相似又有區別的兩個概念。

并行性是指兩個或多個事件在同一時刻發生。而併發性是指兩個或多個事件在同一時間間隔內發生。

在多道程序環境下，併發性是指在一段時間內宏觀上有多個程序在同時運行，但在單處理機環境下（一個處理器），每一時刻卻僅能有一道程序執行，故微觀上這些程序只能是分時地交替執行。例如，在 1 秒鐘時間內，0 – 15 ms 程序 A 運行；15 – 30 ms 程序 B 運行；30 – 45 ms 程序 C 運行；45 – 60 ms 程序 D 運行，因此可以說，在 1 秒鐘時間間隔內，宏觀上有四道程序在同時運行，但微觀上，程序 A、B、C、D 是分時地交替執行的。

如果在計算機系統中有多個處理機，這些可以併發執行的程序就可以被分配到多個處理機上，實現併發執行，即利用每個處理機愛處理一個可併發執行的程序。這樣，多個程序便可以同時執行。以此就能提高系統中的資源利用率，增加系統的吞吐量。

進程和線程

進程是指一個內存中運行的應用程序。一個應用程序可以同時啟動多個進程，那麼上面的問題就有了解決的思路：我們啟動兩個進程，一個用來打遊戲，一個用來播放音樂。這當然是一種解決方案，但是想象一下，如果一個應用程序需要執行的任務非常多，例如 LOL 遊戲吧，光是需要播放的音樂就有非常多，人物本身的語音，技能的音效，遊戲的背景音樂，塔攻擊的聲音等等等，還不用說遊戲本身，就光播放音樂就需要創建許多許多的進程，而進程本身是一種非常消耗資源的東西，這樣的設計顯然是不合理的。更何況大多數的操作系統都不需要一個進程訪問其他進程的內存空間，也就是說，進程之間的通信很不方便，此時我們就得引入“線程”這門技術，來解決這個問題。

線程是指進程中的一個執行任務（控制單元），一個進程可以同時併發運行多個線程。我們可以打開任務管理器，觀察到幾乎所有的進程都擁有着許多的「線程」(在 WINDOWS 中線程是默認隱藏的，需要在「查看」裏面點擊「選擇列」，有一個線程數的勾選項，找到並勾選就可以了)。

進程和線程的區別

進程：有獨立的內存空間，進程中的數據存放空間（堆空間和棧空間）是獨立的，至少有一個線程。

線程：堆空間是共享的，棧空間是獨立的，線程消耗的資源也比進程小，相互之間可以影響的，又稱為輕型進程或進程元。

因為一個進程中的多個線程是併發運行的，那麼從微觀角度上考慮也是有先後順序的，那麼哪個線程執行完全取決於 CPU 調度器(JVM 來調度)，程序員是控制不了的。我們可以把多線程併發性看作是多個線程在瞬間搶 CPU 資源，誰搶到資源誰就運行，這也造就了多線程的隨機性。下面我們將看到更生動的例子。

Java 程序的進程(Java 的一個程序運行在系統中)里至少包含主線程和垃圾回收線程(後台線程)，你可以簡單的這樣認為，但實際上有四個線程（了解就好）：

  • [1] main——main 線程，用戶程序入口
  • [2] Reference Handler——清除 Reference 的線程
  • [3] Finalizer——調用對象 finalize 方法的線程
  • [4] Signal Dispatcher——分發處理髮送給 JVM 信號的線程

多線程和單線程的區別和聯繫？

  1. 單核 CPU 中，將 CPU 分為很小的時間片，在每一時刻只能有一個線程在執行，是一種微觀上輪流佔用 CPU 的機制。

  2. 多線程會存在線程上下文切換，會導致程序執行速度變慢，即採用一個擁有兩個線程的進程執行所需要的時間比一個線程的進程執行兩次所需要的時間要多一些。

結論：即採用多線程不會提高程序的執行速度，反而會降低速度，但是對於用戶來說，可以減少用戶的響應時間。

多線程的優勢

儘管面臨很多挑戰，多線程有一些優點仍然使得它一直被使用，而這些優點我們應該了解。

優勢一：資源利用率更好

想象一下，一個應用程序需要從本地文件系統中讀取和處理文件的情景。比方說，從磁盤讀取一個文件需要 5 秒，處理一個文件需要 2 秒。處理兩個文件則需要：

1| 5秒讀取文件A
2| 2秒處理文件A
3| 5秒讀取文件B
4| 2秒處理文件B
5| ---------------------
6| 總共需要14秒

從磁盤中讀取文件的時候，大部分的 CPU 時間用於等待磁盤去讀取數據。在這段時間里，CPU 非常的空閑。它可以做一些別的事情。通過改變操作的順序，就能夠更好的使用 CPU 資源。看下面的順序：

1| 5秒讀取文件A
2| 5秒讀取文件B + 2秒處理文件A
3| 2秒處理文件B
4| ---------------------
5| 總共需要12秒

CPU 等待第一個文件被讀取完。然後開始讀取第二個文件。當第二文件在被讀取的時候，CPU 會去處理第一個文件。記住，在等待磁盤讀取文件的時候，CPU 大部分時間是空閑的。

總的說來，CPU 能夠在等待 IO 的時候做一些其他的事情。這個不一定就是磁盤 IO。它也可以是網絡的 IO，或者用戶輸入。通常情況下，網絡和磁盤的 IO 比 CPU 和內存的 IO 慢的多。

優勢二：程序設計在某些情況下更簡單

在單線程應用程序中，如果你想編寫程序手動處理上面所提到的讀取和處理的順序，你必須記錄每個文件讀取和處理的狀態。相反，你可以啟動兩個線程，每個線程處理一個文件的讀取和操作。線程會在等待磁盤讀取文件的過程中被阻塞。在等待的時候，其他的線程能夠使用 CPU 去處理已經讀取完的文件。其結果就是，磁盤總是在繁忙地讀取不同的文件到內存中。這會帶來磁盤和 CPU 利用率的提升。而且每個線程只需要記錄一個文件，因此這種方式也很容易編程實現。

優勢三：程序響應更快

有時我們會編寫一些較為複雜的代碼（這裏的複雜不是說複雜的算法，而是複雜的業務邏輯），例如，一筆訂單的創建，它包括插入訂單數據、生成訂單趕快找、發送郵件通知賣家和記錄貨品銷售數量等。用戶從單擊“訂購”按鈕開始，就要等待這些操作全部完成才能看到訂購成功的結果。但是這麼多業務操作，如何能夠讓其更快地完成呢？

在上面的場景中，可以使用多線程技術，即將數據一致性不強的操作派發給其他線程處理（也可以使用消息隊列），如生成訂單快照、發送郵件等。這樣做的好處是響應用戶請求的線程能夠盡可能快地處理完成，縮短了響應時間，提升了用戶體驗。

其他優勢

多線程還有一些優勢也顯而易見：

  • 進程之前不能共享內存，而線程之間共享內存(堆內存)則很簡單。
  • 系統創建進程時需要為該進程重新分配系統資源,創建線程則代價小很多,因此實現多任務併發時,多線程效率更高.
  • Java 語言本身內置多線程功能的支持,而不是單純地作為底層系統的調度方式,從而簡化了多線程編程.

上下文切換

即使是單核處理器也支持多線程執行代碼，CPU 通過給每個線程分配 CPU 時間片來實現這個機制。時間片是 CPU 分配給各個線程的時間，因為時間片非常短，所以 CPU 通過不停地切換線程執行，讓我們感覺多個線程是同時執行的，時間片一般是幾十毫秒（ms）。

CPU 通過時間片分配算法來循環執行任務，當前任務執行一個時間片後會切換到下一個任務。但是，在切換前會保存上一個任務的狀態，以便下次切換回這個任務的時候，可以再加載這個任務的狀態。所以任務從保存到再加載的過程就是一次上下文切換。

這就像我們同時讀兩本書，當我們在讀一本英文的技術書時，發現某個單詞不認識，於是打開中英文字典，但是在放下英文技術書之前，大腦必須先記住這本書獨到了多少頁的多少行，等查完單詞之後，能夠繼續讀這本書。這樣的切換是會影響讀書效率的，同樣上下文切換也會影響多線程的執行速度。

二、創建線程的兩種方式

繼承 Thread 類

public class Tester {

    // 播放音樂的線程類
    static class PlayMusicThread extends Thread {

        // 播放時間，用循環來模擬播放的過程
        private int playTime = 50;

        public void run() {
            for (int i = 0; i < playTime; i++) {
                System.out.println("播放音樂" + i);
            }
        }
    }

    // 方式1：繼承 Thread 類
    public static void main(String[] args) {
        // 主線程：運行遊戲
        for (int i = 0; i < 50; i++) {
            System.out.println("打遊戲" + i);
            if (i == 10) {
                // 創建播放音樂線程
                PlayMusicThread musicThread = new PlayMusicThread();
                musicThread.start();
            }
        }
    }
}

運行結果發現打遊戲和播放音樂交替出現，說明已經成功了。

實現 Runnable 接口

public class Tester {

    // 播放音樂的線程類
    static class PlayMusicThread implements Runnable {

        // 播放時間，用循環來模擬播放的過程
        private int playTime = 50;

        public void run() {
            for (int i = 0; i < playTime; i++) {
                System.out.println("播放音樂" + i);
            }
        }
    }

    // 方式2：實現 Runnable 方法
    public static void main(String[] args) {
        // 主線程：運行遊戲
        for (int i = 0; i < 50; i++) {
            System.out.println("打遊戲" + i);
            if (i == 10) {
                // 創建播放音樂線程
                Thread musicThread = new Thread(new PlayMusicThread());
                musicThread.start();
            }
        }
    }
}

也能完成效果。

以上就是傳統的兩種創建線程的方式，事實上還有第三種，我們後邊再講。

多線程一定快嗎？

先來一段代碼，通過并行和串行來分別執行累加操作，分析：下面的代碼併發執行一定比串行執行快嗎？

import org.springframework.util.StopWatch;

// 比較并行和串行執行累加操作的速度
public class Tester {

    // 執行次數
    private static final long COUNT = 100000000;
    private static final StopWatch TIMER = new StopWatch();

    public static void main(String[] args) throws InterruptedException {
        concurrency();
        serial();
        // 打印比較測試結果
        System.out.println(TIMER.prettyPrint());
    }

    private static void serial() {
        TIMER.start("串行執行" + COUNT + "條數據");

        int a = 0;
        for (long i = 0; i < COUNT; i++) {
            a += 5;
        }
        // 串行執行
        int b = 0;
        for (long i = 0; i < COUNT; i++) {
            b--;
        }

        TIMER.stop();
    }

    private static void concurrency() throws InterruptedException {
        TIMER.start("并行執行" + COUNT + "條數據");

        // 通過匿名內部類來創建線程
        Thread thread = new Thread(() -> {
            int a = 0;
            for (long i = 0; i < COUNT; i++) {
                a += 5;
            }
        });
        thread.start();

        // 并行執行
        int b = 0;
        for (long i = 0; i < COUNT; i++) {
            b--;
        }
        // 等待線程結束
        thread.join();
        TIMER.stop();
    }
}

大家可以自己測試一下，每一台機器 CPU 不同測試結果可能也會不同，之前在 WINDOWS 本兒上測試的時候，多線程的優勢從 1 千萬數據的時候才開始體現出來，但是現在換了 MAC，1 億條數據時間也差不多，到 10 億的時候明顯串行就比并行快了… 總之，為什麼併發執行的速度會比串行慢呢？就是因為線程有創建和上下文切換的開銷。

繼承 Thread 類還是實現 Runnable 接口？

想象一個這樣的例子：給出一共 50 個蘋果，讓三個同學一起來吃，並且給蘋果編上號碼，讓他們吃的時候順便要說出蘋果的編號：

運行結果可以看到，使用繼承方式實現，每一個線程都吃了 50 個蘋果。這樣的結果顯而易見：是因為顯式地創建了三個不同的 Person 對象，而每個對象在堆空間中有獨立的區域來保存定義好的 50 個蘋果。

而使用實現方式則滿足要求，這是因為三個線程共享了同一個 Apple 對象，而對象中的 num 數量是一定的。

所以可以簡單總結出繼承方式和實現方式的區別：

繼承方式：

  1. Java 中類是單繼承的，如果繼承了 Thread 了，該類就不能再有其他的直接父類了；
  2. 從操作上分析，繼承方式更簡單，獲取線程名字也簡單..(操作上，更簡單)
  3. 從多線程共享同一個資源上分析，繼承方式不能做到…

實現方式：

  1. Java 中類可以實現多個接口，此時該類還可以繼承其他類，並且還可以實現其他接口(設計上，更優雅)..
  2. 從操作上分析，實現方式稍微複雜點，獲取線程名字也比較複雜，需要使用 Thread.currentThread() 來獲取當前線程的引用..
  3. 從多線程共享同一個資源上分析，實現方式可以做到..

在這裏，三個同學完成搶蘋果的例子，使用實現方式才是更合理的方式。

對於這兩種方式哪種好並沒有一個確定的答案，它們都能滿足要求。就我個人意見，我更傾向於實現 Runnable 接口這種方法。因為線程池可以有效的管理實現了 Runnable 接口的線程，如果線程池滿了，新的線程就會排隊等候執行，直到線程池空閑出來為止。而如果線程是通過實現 Thread 子類實現的，這將會複雜一些。

有時我們要同時融合實現 Runnable 接口和 Thread 子類兩種方式。例如，實現了 Thread 子類的實例可以執行多個實現了 Runnable 接口的線程。一個典型的應用就是線程池。

常見錯誤：調用 run() 方法而非 start() 方法

創建並運行一個線程所犯的常見錯誤是調用線程的 run() 方法而非 start() 方法，如下所示：

1| Thread newThread = new Thread(MyRunnable());
2| newThread.run();  //should be start();

起初你並不會感覺到有什麼不妥，因為 run() 方法的確如你所願的被調用了。但是，事實上，run() 方法並非是由剛創建的新線程所執行的，而是被創建新線程的當前線程所執行了。也就是被執行上面兩行代碼的線程所執行的。想要讓創建的新線程執行 run() 方法，必須調用新線程的 start() 方法。

三、線程的安全問題

吃蘋果遊戲的不安全問題

我們來考慮一下上面吃蘋果的例子，會有什麼問題？

儘管，Java 並不保證線程的順序執行，具有隨機性，但吃蘋果比賽的案例運行多次也並沒有發現什麼太大的問題。這並不是因為程序沒有問題，而只是問題出現的不夠明顯，為了讓問題更加明顯，我們使用 Thread.sleep() 方法（經常用來模擬網絡延遲）來讓線程休息 10 ms，讓其他線程去搶資源。（注意：在程序中並不是使用 Thread.sleep(10)之後,程序才出現問題,而是使用之後,問題更明顯.）

為什麼會出現這樣的錯誤呢？

先來分析第一種錯誤：為什麼會吃重複的蘋果呢？就拿 B 和 C 都吃了編號為 47 的蘋果為例吧：

  • A 線程拿到了編號為 48 的蘋果，打印輸出然後讓 num 減 1，睡眠 10 ms，此時 num 為 47。
  • 這時 B 和 C 同時都拿到了編號為 47 的蘋果，打印輸出，在其中一個線程作出了減一操作的時候，A 線程從睡眠中醒過來，拿到了編號為 46 的蘋果，然後輸出。在這期間並沒有任何操作不允許 B 和 C 線程不能拿到同一個編號的蘋果，之前沒有明顯的錯誤僅僅可能只是因為運行速度太快了。

再來分析第二種錯誤：照理來說只應該存在 1-50 編號的蘋果，可是 0 和-1 是怎麼出現的呢？

  • 當 num = 1 的時候，A，B，C 三個線程同時進入了 try 語句進行睡眠。
  • C 線程先醒過來，輸出了編號為 1 的蘋果，然後讓 num 減一，當 C 線程醒過來的時候發現 num 為 0 了。
  • A 線程醒過來一看，0 都沒有了，只有 -1 了。

歸根結底是因為沒有任何操作來限制線程來獲取相同的資源並對他們進行操作，這就造成了線程安全性問題。

如果我們把打印和減一的操作分成兩個步驟，會更加明顯：

ABC 三個線程同時打印了 50 的蘋果，然後同時做出減一操作。

像這樣的原子操作，是不允許分步驟進行的，必須保證同步進行，不然可能會引發不可設想的後果。

要解決上述多線程併發訪問一個資源的安全性問題，就需要引入線程同步的概念。

線程同步

多個執行線程共享一個資源的情景，是最常見的併發編程情景之一。為了解決訪問共享資源錯誤或數據不一致的問題，人們引入了臨界區的概念：用以訪問共享資源的代碼塊，這個代碼塊在同一時間內只允許一個線程執行。

為了幫助編程人員實現這個臨界區，Java（以及大多數編程語言）提供了同步機制，當一個線程試圖訪問一個臨界區時，它將使用一種同步機制來查看是不是已經有其他線程進入臨界區。如果沒有其他線程進入臨界區，他就可以進入臨界區。如果已經有線程進入了臨界區，它就被同步機制掛起，直到進入的線程離開這個臨界區。如果在等待進入臨界區的線程不止一個，JVM 會選擇其中的一個，其餘的將繼續等待。

synchronized 關鍵字

如果一個對象已用 synchronized 關鍵字聲明，那麼只有一個執行線程被允許訪問它。使用 synchronized 的好處顯而易見：保證了多線程併發訪問時的同步操作，避免線程的安全性問題。但是壞處是：使用 synchronized 的方法/代碼塊的性能比不用要低一些。所以好的做法是：盡量減小 synchronized 的作用域。

我們還是先來解決吃蘋果的問題，考慮一下 synchronized 關鍵字應該加在哪裡呢？

發現如果還再把 synchronized 關鍵字加在 if 裏面的話，0 和 -1 又會出來了。這其實是因為當 ABC 同是進入到 if 語句中，等待臨界區釋放的時，拿到 1 編號的線程已經又把 num 減一操作了，而此時最後一個等待臨界區的進程拿到的就會是 -1 了。

同步鎖 Lock

Lock 機制提供了比 synchronized 代碼塊和 synchronized 方法更廣泛的鎖定操作，同步代碼塊/ 同步方法具有的功能 Lock 都有，除此之外更強大，更體現面向對象。在併發包的類族中，Lock 是 JUC 包的頂層接口，它的實現邏輯並未用到 synchronized，而是利用了 volatile 的可見性。

使用 Lock 最典型的代碼如下：

class X {

    private final ReentrantLock lock = new ReentrantLock();

    public void m() {
        lock.lock();
        try {
            // ..... method body
        } finally {
            lock.unlock();
        }
    }
}

線程安全問題

線程安全問題只在多線程環境下才會出現，單線程串行執行不存在此類問題。保證高併發場景下的線程安全，可以從以下四個維度考量：

維度一：數據單線程可見

單線程總是安全的。通過限制數據僅在單線程內可見，可以避免數據被其他線程篡改。最典型的就是線程局部變量，它存儲在獨立虛擬機棧幀的局部變量表中，與其他線程毫無瓜葛。TreadLocal 就是採用這種方式來實現線程安全的。

維度二：只讀對象

只讀對象總是安全的。它的特性是允許複製、拒絕寫入。最典型的只讀對象有 String、Integer 等。一個對象想要拒絕任何寫入，必須要滿足以下條件：

  • 使用 final 關鍵字修飾類，避免被繼承；
  • 使用 private final 關鍵字避免屬性被中途修改；
  • 沒有任何更新方法；
  • 返回值不能為可變對象。

維度三：線程安全類

某些線程安全類的內部有非常明確的線程安全機制。比如 StringBuffer 就是一個線程安全類，它採用 synchronized 關鍵字來修飾相關方法。

維度四：同步與鎖機制

如果想要對某個對象進行併發更新操作，但又不屬於上述三類，需要開發工程師在代碼中實現安全的同步機制。雖然這個機制支持的併發場景很有價值，但非常複雜且容易出現問題。

處理線程安全的核心理念

要麼只讀，要麼加鎖。

合理利用好 JDK 提供的併發包，往往能化腐朽為神奇。Java 併發包（java.util.concurrent，JUC）中大多數類註釋都寫有：@author Doug Lea。如果說 Java 是一本史書，那麼 Doug Lea 絕對是開疆拓土的偉大人物。Doug Lea 在當大學老師時，專攻併發編程和併發數據結構設計，主導設計了 JUC 併發包，提高了 Java 併發編程的易用性，大大推進了 Java 的商用進程。

參考資料

  • 《Java 零基礎入門教程》 –
  • 《Java 併發編程的藝術》
  • 《Java 7 併發編程實戰手冊》
  • 《碼出高效 Java 開發手冊》 – 楊冠寶（孤盡） 高海慧（鳴莎）著

按照慣例黏一個尾巴：

歡迎轉載，轉載請註明出處！
獨立域名博客：wmyskxz.com
簡書 ID：
github：
歡迎關注公眾微信號：wmyskxz
分享自己的學習 & 學習資料 & 生活
想要交流的朋友也可以加 qq 群：3382693

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

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

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

※3c收購,鏡頭 收購有可能以全新價回收嗎?

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