標籤: 網頁設計

  • 談談我對 Flutter 未來發展 和 “嵌套地獄” 的淺顯看法

    談談我對 Flutter 未來發展 和 “嵌套地獄” 的淺顯看法

    Flutter 未來發展

    提到 Flutter 就不得不提到 Fuchsia 系統,這是一個尚未正式發布的操作的系統,引用 Android 和 Chrome 的高級副總裁 Hiroshi Lockheimer 在一檔播客節目中對 Fuchsia 的介紹是:

    不僅僅是手機和個人電腦,在物聯網的世界里,越來越多的設備需要操作系統、新的軟件運行環境等支持。我認為,在具有不同優勢和專業化的諸多操作系統中還存在很大的發展空間。Fuchsia 就是其中之一,所以,請繼續保持關注。

    是的,Fuchsia 系統是為物聯網研發的操作系統,物聯網簡稱 IoT,現在全世界都在押注 IoT,包括華為、小米等國內公司。

    那 Flutter 和 Fuchsia 又有什麼關係呢?

    Flutter 是 Fuchsia 官方指定的唯一UI開發框架。

    現在有很多物聯網操作系統 ,Fuchsia 就一定可以脫穎而出嗎?

    不一定,未來的事情誰說的准呢,但在我看來 Fuchsia 是最有可能發展起來的物聯網操作系統,因為一個操作系統的發展除了本身優秀以外,最大的阻礙其實是生態,而 Fuchsia 在生態方面具有天然的優勢, 國外的一篇報道曾說:

    Google 希望將 Android App 無縫移植到 Fuchsia 上,而且一直在做相關工作。

    試想一下,一旦 Google 將 Android App 無縫移植到 Fuchsia 上,其他物聯網操作系統如何與之抗衡。

    這裏引用 Google 公眾號底部的一句話送給大家:

    預測未來不如創造未來

    在跨平台技術上 Flutter 還有很多競爭對手,比如 HTML5、React Native、Weex、快應用、小程序等,我曾在跨平台技術發展簡介 中詳細說明了各個跨平台技術的發展歷史及優缺點。

    Flutter 的出現會終結其他跨平台技術?我想不會的, React Native 發展了這麼多年也沒有完全乾掉 HTML5,應為 HTML5 有其獨特的應用場景,比如 營銷活動場景、新聞或者博客詳情頁面等,這些場景非常適合 HTML5。因此 Flutter 也不可能終結其他跨平台技術,總結一句話就是:

    未來很長一段時間,將會是跨平台技術共存的時代,但 Flutter 適用場景更為廣闊。

    Flutter 嵌套地獄

    現在網絡上對 Flutter 吐槽最多大概就是 Flutter “嵌套地獄”寫法了,為什麼會出現這種現象?個人認為最大的原因就是目前大部分開源的 Flutter 項目都是這種嵌套寫法(包括我自己以前也是如此),導致後來的初學者認為這麼寫沒有問題,當項目越來越複雜時,這種嵌套寫法給項目的維護帶來了巨大的挑戰。下面說說如何避免這種嵌套寫法?

    比如實現如下效果:

    嵌套地獄 的寫法:

    @override
    Widget build(BuildContext context) {
      return Column(
        children: <Widget>[
          Container(
            height: 45,
            child: Row(
              children: <Widget>[
                SizedBox(
                  width: 30,
                ),
                Icon(
                  Icons.notifications,
                  color: Colors.blue,
                ),
                SizedBox(
                  width: 30,
                ),
                Expanded(
                  child: Text('消息中心'),
                ),
                Container(
                  padding: EdgeInsets.symmetric(horizontal: 10),
                  decoration: BoxDecoration(
                      shape: BoxShape.rectangle,
                      borderRadius: BorderRadius.all(Radius.circular(50)),
                      color: Colors.red),
                  child: Text(
                    '2',
                    style: TextStyle(color: Colors.white),
                  ),
                ),
                SizedBox(
                  width: 15,
                ),
              ],
            ),
          ),
          Divider(),
          //類似上面的布局寫6個
        ],
      );
    }
    

    上面還僅僅是第一項的布局,下面還有7個,一個30多行代碼,7個就是200多行的布局代碼,這還僅僅是布局代碼,如果加上邏輯,都不敢想象啊。

    或許有一點封裝思想開發者會將每一個 Item封裝為一個方法,寫法如下:

    _buildItem(IconData iconData, Color iconColor, String title, Widget widget) {
      return Container(
        height: 45,
        child: Row(
          children: <Widget>[
            SizedBox(
              width: 30,
            ),
            Icon(
              iconData,
              color: iconColor,
            ),
            SizedBox(
              width: 30,
            ),
            Expanded(
              child: Text('$title'),
            ),
            widget,
            SizedBox(
              width: 15,
            ),
          ],
        ),
      );
    }
    
    @override
    Widget build(BuildContext context) {
      return Column(
        children: <Widget>[
          _buildItem(...),
          Divider(),
          _buildItem(...),
          Divider(),
          _buildItem(...),
          Divider(),
          _buildItem(...),
          Divider(),
          _buildItem(...),
          Divider(),
          _buildItem(...),
          Divider(),
        ],
      );
    }
    

    這樣看起來好多了,基本解決了嵌套地獄問題,但這樣寫還存在一個非常大的問題-性能問題,一旦其中一個数字發生變化,整個頁面都要重建,Flutter 開發中非常重要的一個原則就是 盡可能少的重建組件,因此將上面封裝到方法中組件變為一個 Widget。

    class SettingDemo extends StatelessWidget {
      @override
      Widget build(BuildContext context) {
        return Column(
          children: <Widget>[
            _SettingItem(
              iconData: Icons.notifications,
              iconColor: Colors.blue,
              title: '消息中心',
              suffix: _NotificationsText(
                text: '2',
              ),
            ),
            Divider(),
            _SettingItem(
              iconData: Icons.thumb_up,
              iconColor: Colors.green,
              title: '我贊過的',
              suffix: _Suffix(
                text: '121篇',
              ),
            ),
            Divider(),
            _SettingItem(
              iconData: Icons.grade,
              iconColor: Colors.yellow,
              title: '收藏集',
              suffix: _Suffix(
                text: '2個',
              ),
            ),
            Divider(),
            _SettingItem(
              iconData: Icons.shopping_basket,
              iconColor: Colors.yellow,
              title: '已購小冊',
              suffix: _Suffix(
                text: '100個',
              ),
            ),
            Divider(),
            _SettingItem(
              iconData: Icons.account_balance_wallet,
              iconColor: Colors.blue,
              title: '我的錢包',
              suffix: _Suffix(
                text: '10萬',
              ),
            ),
            Divider(),
            _SettingItem(
              iconData: Icons.location_on,
              iconColor: Colors.grey,
              title: '閱讀過的文章',
              suffix: _Suffix(
                text: '1034篇',
              ),
            ),
            Divider(),
            _SettingItem(
              iconData: Icons.local_offer,
              iconColor: Colors.grey,
              title: '標籤管理',
              suffix: _Suffix(
                text: '27個',
              ),
            ),
          ],
        );
      }
    }
    
    class _SettingItem extends StatelessWidget {
      const _SettingItem(
          {Key key, this.iconData, this.iconColor, this.title, this.suffix})
          : super(key: key);
    
      final IconData iconData;
      final Color iconColor;
      final String title;
      final Widget suffix;
    
      @override
      Widget build(BuildContext context) {
        return Container(
          height: 45,
          child: Row(
            children: <Widget>[
              SizedBox(
                width: 30,
              ),
              Icon(iconData,color: iconColor,),
              SizedBox(
                width: 30,
              ),
              Expanded(
                child: Text('$title'),
              ),
              suffix,
              SizedBox(
                width: 15,
              ),
            ],
          ),
        );
      }
    }
    
    class _NotificationsText extends StatelessWidget {
      final String text;
    
      const _NotificationsText({Key key, this.text}) : super(key: key);
    
      @override
      Widget build(BuildContext context) {
        return Container(
          padding: EdgeInsets.symmetric(horizontal: 10),
          decoration: BoxDecoration(
              shape: BoxShape.rectangle,
              borderRadius: BorderRadius.all(Radius.circular(50)),
              color: Colors.red),
          child: Text(
            '$text',
            style: TextStyle(color: Colors.white),
          ),
        );
      }
    }
    
    class _Suffix extends StatelessWidget {
      final String text;
    
      const _Suffix({Key key, this.text}) : super(key: key);
    
      @override
      Widget build(BuildContext context) {
        return Text(
          '$text',
          style: TextStyle(color: Colors.grey.withOpacity(.5)),
        );
      }
    }
    

    封裝為一個個單獨的小組件,將有變化的組件盡量單獨封裝,這樣就不會重建整個控件樹,增強了可讀性和可維護性,而且對性能有很大的提升。

    最後總結一句:

    雖然 Flutter 一切皆是組件,但並不代表一切都要寫在組件中。

    當然這僅僅是我個人的看法,如果您有更好的方法歡迎一起討論,從我做起,規範寫法,為 Flutter 發展貢獻做出一點微不足道的貢獻。

    交流

    老孟Flutter博客地址(330個控件用法):http://laomengit.com

    歡迎加入Flutter交流群(微信:laomengit)、關注公眾號【老孟Flutter】:

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

    【其他文章推薦】

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

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※想知道最厲害的網頁設計公司"嚨底家"!

    ※幫你省時又省力,新北清潔一流服務好口碑

    ※別再煩惱如何寫文案,掌握八大原則!

  • MongoDB副本集replica set (二)–副本集環境搭建

    (一)主機信息

    操作系統版本:centos7 64-bit

    數據庫版本   :MongoDB 4.2 社區版

    ip hostname
    192.168.10.41 mongoserver1
    192.168.10.42 mongoserver2
    192.168.10.43 mongoserver3

    (二)副本集搭建過程

    首先需要在3台服務器上安裝MongoDB軟件,安裝過程見:https://www.cnblogs.com/lijiaman/p/12983589.html。安裝完成之後,即可進行後續的配置,具體操作如下:

    (1)在一台機器上創建keyfile

    openssl rand -base64 756 > /mongo/mongo-keyfile
    chmod 400 /mongo/mongo-keyfile

    (2)拷貝feyfile到所有節點

    scp /mongo/mongo-keyfile root@192.168.10.42:/mongo/
    scp /mongo/mongo-keyfile root@192.168.10.43:/mongo/

    (3)以啟用身份驗證的方式開啟所有節點
    這裏將所有參數設置到配置文件裏面,方便管理,配置文件如下:

    [root@mongodbserver1 mongo]# cat /etc/mongod.conf
    # mongod.conf
    
    # for documentation of all options, see:
    # http://docs.mongodb.org/manual/reference/configuration-options/
    
    # where to write logging data.
    systemLog:
    destination: file
    logAppend: true
    path: /mongo/mongod.log
    
    # Where and how to store data.
    storage:
    dbPath: /mongo/data
    journal:
    enabled: true
    # engine:
    # mmapv1:
    # wiredTiger:
    
    # how the process runs
    processManagement:
    fork: true # fork and run in background
    pidFilePath: /mongo/mongod.pid # location of pidfile
    
    # network interfaces
    net:
    port: 27017
    bindIp: 0.0.0.0 # Listen to local interface only, comment to listen on all interfaces.
    
    security:
    authorization: enabled                 # 啟用身份驗證
    keyFile: /mongo/mongo-keyfile         # 配置keyfile文件
     
    replication:
    replSetName: rstest                    # 設置副本集名稱

    然後啟動所有節點,以節點1為例:

    [root@mongodbserver1 mongo]# mongod -f /etc/mongod.conf

    (4)初始化副本集
    在其中一個節點執行以下腳本初始化副本集,只需在一個節點上執行即可。

    rs.initiate(
    {
    _id : "rstest",
    members: [
    { _id : 0, host : "192.168.10.41:27017" },
    { _id : 1, host : "192.168.10.42:27017" },
    { _id : 2, host : "192.168.10.43:27017" }
    ]
    }
    )

    參數含義:
    _id          :副本集的名稱
    members :副本集的成員信息

    在初始化時,會觸發投票選舉一個主節點,可以使用rs.status()來確定主節點成員

    rstest:SECONDARY> rs.status()
    ...
    "members" : [
    {
    "_id" : 0,
    "name" : "192.168.10.41:27017",
    "health" : 1,
    "state" : 1,
    "stateStr" : "PRIMARY",
    "uptime" : 280,
    "optime" : {
    "ts" : Timestamp(1592897767, 1),
    "t" : NumberLong(1)
    },
    "optimeDate" : ISODate("2020-06-23T07:36:07Z"),
    "syncingTo" : "",
    "syncSourceHost" : "",
    "syncSourceId" : -1,
    "infoMessage" : "",
    "electionTime" : Timestamp(1592897607, 1),
    "electionDate" : ISODate("2020-06-23T07:33:27Z"),
    "configVersion" : 1,
    "self" : true,
    "lastHeartbeatMessage" : ""
    },
    ...

    (5)創建管理員用戶
    第一個用戶必須要有創建其它用戶的權限,例如需要有userAdminAnyDatabase權限,並且需要創建在admin數據庫中。
    因為是在副本集上創建用戶,故要在主節點上執行。如創建root用戶

    use admin;
    
    db.createUser(
    {
    user:"root",
    pwd:"123456",
    roles:[{role:"userAdminAnyDatabase",db:"admin"}]
    }
    )

    (6)以管理員身份登錄數據庫
    通過以下方式以管理員身份登錄到數據庫

    mongo -u root -p 123456 --authenticationDatabase admin

    (7)創建一個集群管理員賬戶
    clusterAdmin角色被授予副本集操作的權限,如配置副本集。在admin數據庫中創建一個集群管理員並授予clusterAdmin角色。

    use admin
    
    db.createUser(
    {
    "user" : "replica",
    "pwd" : "replica",
    roles: [ { "role" : "clusterAdmin", "db" : "admin" } ]
    }
    )

    (8)要啟用身份驗證,需要重啟數據庫
    重啟完成后,就需要以用戶密碼方式登錄數據庫了,假如不使用用戶名密碼,可以登錄數據庫,但是無法訪問數據

    [root@mongodbserver2 mongo]# mongo
    MongoDB shell version v4.2.7
    connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
    Implicit session: session { "id" : UUID("d49b410b-a7af-4550-a455-faa82885517b") }
    MongoDB server version: 4.2.7
    rstest:PRIMARY> show dbs
    rstest:PRIMARY> 
    rstest:PRIMARY> db
    test

    只有使用了用戶名密碼,才能查到數據:

    [root@mongodbserver2 mongo]# mongo -u root -p 123456 --authenticationDatabase admin 
    MongoDB shell version v4.2.7
    connecting to: mongodb://127.0.0.1:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb
    Implicit session: session { "id" : UUID("a1f0da48-1266-4766-a9e4-32b97a46c3ec") }
    MongoDB server version: 4.2.7
    rstest:PRIMARY> 
    rstest:PRIMARY> show dbs
    admin 0.000GB
    config 0.000GB
    local 0.000GB

    【完】

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

    【其他文章推薦】

    新北清潔公司,居家、辦公、裝潢細清專業服務

    ※別再煩惱如何寫文案,掌握八大原則!

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※超省錢租車方案

    ※教你寫出一流的銷售文案?

  • 氣候變遷衝擊農民生計 菲青年下鄉助行銷轉型

    摘錄自2019年10月2日中央社報導

    菲律賓存在乾季和雨季,但氣候變遷改變降雨季節,衝擊農民生計。為此,25名菲律賓青年創業家組成的「根源聯合會」(Roots Collective)與「和平與公平基金會」(Peace and Equity Foundation)合作,即日起到6日在位於大馬尼拉「波尼法西奧堡環球城」(BGC)的商場展售在地農民、手工藝工作者與社會企業合作開發的織品、包包、鞋子、食品及日用品。

    青年創業家佛蘭查(John Francia)與夥伴創立「編織工藝」(Woven Crafts),行銷販售來自菲律賓東部薩馬省(Samar)巴席鎮(Basey)的織品,並開發出筆電包、手拿包、化妝包等新產品。佛蘭查說,他們正把觸角延伸到民答那峨島和2017年受叛亂襲擊的馬拉韋市(Marawi)等地,希望開發新的工藝素材,幫助更多菲律賓貧困社區提高收入、脫離貧窮。

    本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

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

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※台北網頁設計公司全省服務真心推薦

    ※想知道最厲害的網頁設計公司"嚨底家"!

    新北清潔公司,居家、辦公、裝潢細清專業服務

    ※推薦評價好的iphone維修中心

  • 沒有廁所的大廈──日本核廢燃料棒處理概況

    文:宋瑞文

    本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

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

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

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

    ※教你寫出一流的銷售文案?

    ※超省錢租車方案

  • 用廢棄物鋪路 越南首條回收塑膠道路啟用

    摘錄自2019年10月3日中央社報導

    越南第一條用廢棄塑膠鋪成的200公尺長道路日前在海防市啟用。這項以廢棄塑膠鋪路的提案由DOW CHEMICAL VIETNAM公司、海防市(Hai Phong)廷武(Dinh Vu)工業區(Deep C)開發商與越南航海大學等單位合作展開,其中第一階段在這個工業區內完成興建以廢棄塑膠鋪成的200公尺長道路。

    越南媒體報導,大量回收塑膠廢棄物由當地環保單位提供,經清洗、烘乾與壓碎後,在攝氏150至180度的溫度下與瀝青混合,隨後用來鋪路;這個塑膠和瀝青混合的材料,有利提升道路耐用度。

    越南商工總會(VCCI)表示,塑膠廢棄物處理的新出路符合於越南政府所提出經濟永續發展政策以及「全國反對塑膠垃圾行動」,這個模式應在各其他地方擴大實施。

    本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

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

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

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

    ※別再煩惱如何寫文案,掌握八大原則!

  • 中國新鑽井平台是否進入南海 越南密切關注

    摘錄自2019年10月3日中央社報導

    中國新鑽井平台「海洋石油982」傳出在海上準備運作,或許會在南海使用。越南政府今天表示,正在查證這個消息,強調各方在南海的任何行動都要遵守1982年聯合國海洋法公約。

    越南外交部今天在河內舉行例行記者會,發言人黎氏秋恆(Le Thi Thu Hang)回答記者提問時表示,越南相關部門密切關注且正在查證中華人民共和國可能將「海洋石油982」鑽井平台駛入南海海域(越稱東海)的消息。

    黎氏秋恆說:「越南認為,(各方)在東海的任何行動都要遵守1982年聯合國海洋法公約,包括遵守沿海國家主權、主權權利和管轄權在內,為維護區域和平與穩定做出切實貢獻。」

    本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

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

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

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

    南投搬家公司費用需注意的眉眉角角,別等搬了再說!

    新北清潔公司,居家、辦公、裝潢細清專業服務

    ※教你寫出一流的銷售文案?

  • 科學家發現具有三類性別的線蟲 砷耐受性極高

    環境資訊中心綜合外電;姜唯 編譯;林大利 審校

    本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

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

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※想知道最厲害的網頁設計公司"嚨底家"!

    ※幫你省時又省力,新北清潔一流服務好口碑

    ※別再煩惱如何寫文案,掌握八大原則!

  • 米塔颱風襲南韓已釀9死 日本高知暴雨淹大水

    摘錄自2019年10月3日自由時報報導

    米塔颱風在週三晚間襲擊南韓南部,南韓南部港口城市釜山發生土石流,南韓行政安全部3日表示,截至下午,全國共有9人喪生,但傷亡人數預計會在攀升,因為還有數人下落不明。

    南韓國防部表示,米塔風災造成1000多棟房屋損壞,超過1500人提前被撤離。

    米塔離開朝鮮半島後,已往日本西部前進,同樣帶來驚人雨量,日本氣象廳警告,儘管米塔颱風可能在4日減弱為溫帶氣旋,但朝著日本北部前進時,強風豪雨可能引發洪水、土石流等災情。

    【動画】高知県内で大雨 道路冠水も

    — 高知新聞 (公式)Kochinews (@Kochi_news)

    本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

    新北清潔公司,居家、辦公、裝潢細清專業服務

    ※別再煩惱如何寫文案,掌握八大原則!

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※超省錢租車方案

    ※教你寫出一流的銷售文案?

  • 搞定ReentrantReadWriteLock 幾道小小數學題就夠了

    搞定ReentrantReadWriteLock 幾道小小數學題就夠了

    | 好看請贊,養成習慣

    • 你有一個思想,我有一個思想,我們交換后,一個人就有兩個思想

    • If you can NOT explain it simply, you do NOT understand it well enough

    現陸續將Demo代碼和技術文章整理在一起 Github實踐精選 ,方便大家閱讀查看,本文同樣收錄在此,覺得不錯,還請Star

    前言

    • 文章 Java AQS隊列同步器以及ReentrantLock的應用 介紹了AQS獨佔式獲取同步狀態的實現,並以 ReentrantLock 為例說明其是如何自定義同步器實現互斥鎖的
    • 文章 Java AQS共享式獲取同步狀態及Semaphore的應用分析 介紹 AQS 共享式獲取同步狀態的實現,並說明了 Semaphore 是如何自定義同步器實現簡單限流作用的

    有了以上兩篇文章的鋪墊,來理解本文要介紹的既有獨佔式,又有共享式獲取同步狀態的 ReadWriteLock,就非常輕鬆了

    ReadWriteLock

    ReadWriteLock 直譯過來為【讀寫鎖】。現實中,讀多寫少的業務場景是非常普遍的,比如應用緩存

    一個線程將數據寫入緩存,其他線程可以直接讀取緩存中的數據,提高數據查詢效率

    之前提到的互斥鎖都是排他鎖,也就是說同一時刻只允許一個線程進行訪問,當面對可共享讀的業務場景,互斥鎖顯然是比較低效的一種處理方式。為了提高效率,讀寫鎖模型就誕生了

    效率提升是一方面,但併發編程更重要的是在保證準確性的前提下提高效率

    一個寫線程改變了緩存中的值,其他讀線程一定是可以 “感知” 到的,否則可能導致查詢到的值不準確

    所以關於讀寫鎖模型就了下面這 3 條規定:

    1. 允許多個線程同時讀共享變量
    2. 只允許一個線程寫共享變量
    3. 如果寫線程正在執行寫操作,此時則禁止其他讀線程讀共享變量

    ReadWriteLock 是一個接口,其內部只有兩個方法:

    public interface ReadWriteLock {
        // 返回用於讀的鎖
        Lock readLock();
    
        // 返回用於寫的鎖
        Lock writeLock();
    }
    

    所以要了解整個讀/寫鎖的整個應用過程,需要從它的實現類 ReentrantReadWriteLock 說起

    ReentrantReadWriteLock 類結構

    直接對比ReentrantReadWriteLock 與 ReentrantLock的類結構

    他們又很相似吧,根據類名稱以及類結構,按照咱們前序文章的分析,你也就能看出 ReentrantReadWriteLock 的基本特性:

    其中黃顏色標記的的 鎖降級 是看不出來的, 這裏先有個印象,下面會單獨說明

    另外,不知道你是否還記得,Java AQS隊列同步器以及ReentrantLock的應用 說過,Lock 和 AQS 同步器是一種組合形式的存在,既然這裡是讀/寫兩種鎖,他們的組合模式也就分成了兩種:

    1. 讀鎖與自定義同步器的聚合
    2. 寫鎖與自定義同步器的聚合
        public ReentrantReadWriteLock(boolean fair) {
            sync = fair ? new FairSync() : new NonfairSync();
            readerLock = new ReadLock(this);
            writerLock = new WriteLock(this);
        }
    

    這裏只是提醒大家,模式沒有變,不要被讀/寫兩種鎖迷惑

    基本示例

    說了這麼多,如果你忘了前序知識,整體理解感覺應該是有斷檔的,所以先來看個示例(模擬使用緩存)讓大家對 ReentrantReadWriteLock 有個直觀的使用印象

    public class ReentrantReadWriteLockCache {
    
    	// 定義一個非線程安全的 HashMap 用於緩存對象
    	static Map<String, Object> map = new HashMap<String, Object>();
    	// 創建讀寫鎖對象
    	static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    	// 構建讀鎖
    	static Lock rl = readWriteLock.readLock();
    	// 構建寫鎖
    	static Lock wl = readWriteLock.writeLock();
    
    	public static final Object get(String key) {
    		rl.lock();
    		try{
    			return map.get(key);
    		}finally {
    			rl.unlock();
    		}
    	}
    
    	public static final Object put(String key, Object value){
    		wl.lock();
    		try{
    			return map.put(key, value);
    		}finally {
    			wl.unlock();
    		}
    	}
    }
    

    你瞧,使用就是這麼簡單。但是你知道的,AQS 的核心是鎖的實現,即控制同步狀態 state 的值,ReentrantReadWriteLock 也是應用AQS的 state 來控制同步狀態的,那麼問題來了:

    一個 int 類型的 state 怎麼既控制讀的同步狀態,又可以控制寫的同步狀態呢?

    顯然需要一點設計了

    讀寫狀態設計

    如果要在一個 int 類型變量上維護多個狀態,那肯定就需要拆分了。我們知道 int 類型數據佔32位,所以我們就有機會按位切割使用state了。我們將其切割成兩部分:

    1. 高16位表示讀
    2. 低16位表示寫

    所以,要想準確的計算讀/寫各自的狀態值,肯定就要應用位運算了,下面代碼是 JDK1.8,ReentrantReadWriteLock 自定義同步器 Sync 的位操作

    abstract static class Sync extends AbstractQueuedSynchronizer {
           
    
            static final int SHARED_SHIFT   = 16;
            static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
            static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
            static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
    
    
            static int sharedCount(int c) { 
              return c >>> SHARED_SHIFT; 
            }
    
            static int exclusiveCount(int c) { 
              return c & EXCLUSIVE_MASK; 
            }
    }
    

    乍一看真是有些複雜的可怕,別慌,咱們通過幾道小小數學題就可以搞定整個位運算過程

    整個 ReentrantReadWriteLock 中 讀/寫狀態的計算就是反覆應用這幾道數學題,所以,在閱讀下面內容之前,希望你搞懂這簡單的運算

    基礎鋪墊足夠了,我們進入源碼分析吧

    源碼分析

    寫鎖分析

    由於寫鎖是排他的,所以肯定是要重寫 AQS 中 tryAcquire 方法

            protected final boolean tryAcquire(int acquires) {        
                Thread current = Thread.currentThread();
              	// 獲取 state 整體的值
                int c = getState();
                // 獲取寫狀態的值
                int w = exclusiveCount(c);
                if (c != 0) {
                    // w=0: 根據推理二,整體狀態不等於零,寫狀態等於零,所以,讀狀態大於0,即存在讀鎖
                  	// 或者當前線程不是已獲取寫鎖的線程
                  	// 二者之一條件成真,則獲取寫狀態失敗
                    if (w == 0 || current != getExclusiveOwnerThread())
                        return false;
                    if (w + exclusiveCount(acquires) > MAX_COUNT)
                        throw new Error("Maximum lock count exceeded");
                    // 根據推理一第 1 條,更新寫狀態值
                    setState(c + acquires);
                    return true;
                }
                if (writerShouldBlock() ||
                    !compareAndSetState(c, c + acquires))
                    return false;
                setExclusiveOwnerThread(current);
                return true;
            }
    

    上述代碼 第 19 行 writerShouldBlock 也並沒有什麼神秘的,只不過是公平/非公平獲取鎖方式的判斷(是否有前驅節點來判斷)

    你瞧,寫鎖獲取方式就是這麼簡單

    讀鎖分析

    由於讀鎖是共享式的,所以肯定是要重寫 AQS 中 tryAcquireShared 方法

            protected final int tryAcquireShared(int unused) {
                Thread current = Thread.currentThread();
                int c = getState();
              	// 寫狀態不等於0,並且鎖的持有者不是當前線程,根據約定 3,則獲取讀鎖失敗
                if (exclusiveCount(c) != 0 &&
                    getExclusiveOwnerThread() != current)
                    return -1;
              	// 獲取讀狀態值
                int r = sharedCount(c);
              	// 這個地方有點不一樣,我們單獨說明
                if (!readerShouldBlock() &&
                    r < MAX_COUNT &&
                    compareAndSetState(c, c + SHARED_UNIT)) {
                    if (r == 0) {
                        firstReader = current;
                        firstReaderHoldCount = 1;
                    } else if (firstReader == current) {
                        firstReaderHoldCount++;
                    } else {
                        HoldCounter rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current))
                            cachedHoldCounter = rh = readHolds.get();
                        else if (rh.count == 0)
                            readHolds.set(rh);
                        rh.count++;
                    }
                    return 1;
                }
              	// 如果獲取讀鎖失敗則進入自旋獲取
                return fullTryAcquireShared(current);
            }
    

    readerShouldBlockwriterShouldBlock 在公平鎖的實現上都是判斷是否有前驅節點,但是在非公平鎖的實現上,前者是這樣的:

    final boolean readerShouldBlock() {
    	return apparentlyFirstQueuedIsExclusive();
    }
    
    final boolean apparentlyFirstQueuedIsExclusive() {
      Node h, s;
      return (h = head) != null &&
        // 等待隊列頭節點的下一個節點
        (s = h.next)  != null &&
        // 如果是排他式的節點
        !s.isShared()         &&
        s.thread != null;
    }
    

    簡單來說,如果請求讀鎖的當前線程發現同步隊列的 head 節點的下一個節點為排他式節點,那麼就說明有一個線程在等待獲取寫鎖(爭搶寫鎖失敗,被放入到同步隊列中),那麼請求讀鎖的線程就要阻塞,畢竟讀多寫少,如果還沒有這點判斷機制,寫鎖可能會發生【飢餓】

    上述條件都滿足了,也就會進入 tryAcquireShared 代碼的第 14 行到第 25 行,這段代碼主要是為了記錄線程持有鎖的次數。讀鎖是共享式的,還想記錄每個線程持有讀鎖的次數,就要用到 ThreadLocal 了,因為這不影響同步狀態 state 的值,所以就不分析了, 只把關係放在這吧

    到這裏讀鎖的獲取也就結束了,比寫鎖稍稍複雜那麼一丟丟,接下來就說明一下那個可能讓你迷惑的鎖升級/降級問題吧

    讀寫鎖的升級與降級

    個人理解:讀鎖是可以被多線程共享的,寫鎖是單線程獨佔的,也就是說寫鎖的併發限制比讀鎖高,所以

    在真正了解讀寫鎖的升級與降級之前,我們需要完善一下本文開頭 ReentrantReadWriteLock 的例子

    	public static final Object get(String key) {
    		Object obj = null;
    		rl.lock();
    		try{
          // 獲取緩存中的值
    			obj = map.get(key);
    		}finally {
    			rl.unlock();
    		}
    		// 緩存中值不為空,直接返回
    		if (obj!= null) {
    			return obj;
    		}
    		
        // 緩存中值為空,則通過寫鎖查詢DB,並將其寫入到緩存中
    		wl.lock();
    		try{
          // 再次嘗試獲取緩存中的值
    			obj = map.get(key);
          // 再次獲取緩存中值還是為空
    			if (obj == null) {
            // 查詢DB
    				obj = getDataFromDB(key); // 偽代碼:getDataFromDB
            // 將其放入到緩存中
    				map.put(key, obj);
    			}
    		}finally {
    			wl.unlock();
    		}
    		return obj;
    	}
    

    有童鞋可能會有疑問

    在寫鎖裏面,為什麼代碼第19行還要再次獲取緩存中的值呢?不是多此一舉嗎?

    其實這裏再次嘗試獲取緩存中的值是很有必要的,因為可能存在多個線程同時執行 get 方法,並且參數 key 也是相同的,執行到代碼第 16 行 wl.lock() ,比如這樣:

    線程 A,B,C 同時執行到臨界區 wl.lock(), 只有線程 A 獲取寫鎖成功,線程B,C只能阻塞,直到線程A 釋放寫鎖。這時,當線程B 或者 C 再次進入臨界區時,線程 A 已經將值更新到緩存中了,所以線程B,C沒必要再查詢一次DB,而是再次嘗試查詢緩存中的值

    既然再次獲取緩存很有必要,我能否在讀鎖里直接判斷,如果緩存中沒有值,那就再次獲取寫鎖來查詢DB不就可以了嘛,就像這樣:

    	public static final Object getLockUpgrade(String key) {
    		Object obj = null;
    		rl.lock();
    		try{
    			obj = map.get(key);
    			if (obj == null){
    				wl.lock();
    				try{
    					obj = map.get(key);
    					if (obj == null) {
    						obj = getDataFromDB(key); // 偽代碼:getDataFromDB
    						map.put(key, obj);
    					}
    				}finally {
    					wl.unlock();
    				}
    			}
    		}finally {
    			rl.unlock();
    		}
    
    		return obj;
    	}
    

    這還真是不可以的,因為獲取一個寫入鎖需要先釋放所有的讀取鎖,如果有兩個讀取鎖試圖獲取寫入鎖,且都不釋放讀取鎖時,就會發生死鎖,所以在這裏,鎖的升級是不被允許的

    讀寫鎖的升級是不可以的,那麼鎖的降級是可以的嘛?這個是 Oracle 官網關於鎖降級的示例 ,我將代碼粘貼在此處,大家有興趣可以點進去連接看更多內容

     class CachedData {
       Object data;
       volatile boolean cacheValid;
       final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
       void processCachedData() {
         rwl.readLock().lock();
         if (!cacheValid) {
            // 必須在獲取寫鎖之前釋放讀鎖,因為鎖的升級是不被允許的
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
              // 再次檢查,原因可能是其他線程已經更新過緩存
              if (!cacheValid) {
                data = ...
                cacheValid = true;
              }
    					//在釋放寫鎖前,降級為讀鎖
              rwl.readLock().lock();
            } finally {
              //釋放寫鎖,此時持有讀鎖
              rwl.writeLock().unlock(); 
            }
         }
    
         try {
           use(data);
         } finally {
           rwl.readLock().unlock();
         }
       }
     }
    

    代碼中聲明了一個 volatile 類型的 cacheValid 變量,保證其可見性。

    1. 首先獲取讀鎖,如果cache不可用,則釋放讀鎖
    2. 然後獲取寫鎖
    3. 在更改數據之前,再檢查一次cacheValid的值,然後修改數據,將cacheValid置為true
    4. 然後在釋放寫鎖前獲取讀鎖 此時
    5. cache中數據可用,處理cache中數據,最後釋放讀鎖

    這個過程就是一個完整的鎖降級的過程,目的是保證數據可見性,聽起來很有道理的樣子,那麼問題來了:

    上述代碼為什麼在釋放寫鎖之前要獲取讀鎖呢?

    如果當前的線程A在修改完cache中的數據后,沒有獲取讀鎖而是直接釋放了寫鎖;假設此時另一個線程B 獲取了寫鎖並修改了數據,那麼線程A無法感知到數據已被修改,但線程A還應用了緩存數據,所以就可能出現數據錯誤

    如果遵循鎖降級的步驟,線程A 在釋放寫鎖之前獲取讀鎖,那麼線程B在獲取寫鎖時將被阻塞,直到線程A完成數據處理過程,釋放讀鎖,從而保證數據的可見性

    那問題又來了:

    使用寫鎖一定要降級嗎?

    如果你理解了上面的問題,相信這個問題已經有了答案。假如線程A修改完數據之後, 經過耗時操作后想要再使用數據時,希望使用的是自己修改后的數據,而不是其他線程修改后的數據,這樣的話確實是需要鎖降級;如果只是希望最後使用數據的時候,拿到的是最新的數據,而不一定是自己剛修改過的數據,那麼先釋放寫鎖,再獲取讀鎖,然後使用數據也無妨

    在這裏我要額外說明一下你可能存在的誤解:

    • 如果已經釋放了讀鎖再獲取寫鎖不叫鎖的升級

    • 如果已經釋放了寫鎖在獲取讀鎖也不叫鎖的降級

    相信你到這裏也理解了鎖的升級與降級過程,以及他們被允許或被禁止的原因了

    總結

    本文主要說明了 ReentrantReadWriteLock 是如何應用 state 做位拆分實現讀/寫兩種同步狀態的,另外也通過源碼分析了讀/寫鎖獲取同步狀態的過程,最後又了解了讀寫鎖的升級/降級機制,相信到這裏你對讀寫鎖已經有了一定的理解。如果你對文中的哪些地方覺得理解有些困難,強烈建議你回看本文開頭的兩篇文章,那裡鋪墊了非常多的內容。接下來我們就看看在應用AQS的最後一個併發工具類 CountDownLatch 吧

    靈魂追問

    1. 讀鎖也沒修改數據,還允許共享式獲取,那還有必要設置讀鎖嗎?
    2. 在分佈式環境中,你是如何保證緩存數據一致性的呢?
    3. 當你打開看ReentrantReadWriteLock源碼時,你會發現,WriteLock 中可以使用 Condition,但是ReadLock 使用Condition卻會拋出UnsupportedOperationException,這是為什麼呢?
    // WriteLock
    public Condition newCondition() {
    	return sync.newCondition();
    }
    
    // ReadLock
    public Condition newCondition() {
    	throw new UnsupportedOperationException();
    }
    

    個人博客:https://dayarch.top
    加我微信好友, 進群娛樂學習交流,備註「進群」

    歡迎持續關注公眾號:「日拱一兵」

    • 前沿 Java 技術乾貨分享
    • 高效工具匯總 | 回復「工具」
    • 面試問題分析與解答
    • 技術資料領取 | 回復「資料」

    以讀偵探小說思維輕鬆趣味學習 Java 技術棧相關知識,本着將複雜問題簡單化,抽象問題具體化和圖形化原則逐步分解技術問題,技術持續更新,請持續關注……

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

    【其他文章推薦】

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

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※想知道最厲害的網頁設計公司"嚨底家"!

    ※幫你省時又省力,新北清潔一流服務好口碑

    ※別再煩惱如何寫文案,掌握八大原則!

  • 使用反應式關係數據庫連接規範R2DBC操作MySQL數據庫

    使用反應式關係數據庫連接規範R2DBC操作MySQL數據庫

    1. 簡介

    三月份已經介紹過R2DBC,它是一種異步的、非阻塞的關係式數據庫連接規範。儘管一些NoSQL數據庫供應商為其數據庫提供了反應式數據庫客戶端,但對於大多數項目而言,遷移到NoSQL並不是一個理想的選擇。這促使了一個通用的響應式關係數據庫連接規範的誕生。 作為擁有龐大用戶群的關係式數據庫MySQL也有了反應式驅動,不過並不是官方的。但是Spring官方將其納入了依賴池,說明該類庫的質量並不低。所以今天就嘗嘗鮮,試一下使用R2DBC連接MySQL

    2. 環境依賴

    基於Spring Boot 2.3.1Spring Data R2DBC,還有反應式Web框架Webflux,同時也要依賴r2dbc-mysql庫,所有的Maven依賴為:

           <!--r2dbc mysql 庫-->
            <dependency>
                <groupId>dev.miku</groupId>
                <artifactId>r2dbc-mysql</artifactId>
            </dependency>
            <!--Spring r2dbc 抽象層-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-r2dbc</artifactId>
            </dependency>
            <!--自動配置需要引入的一個嵌入式數據庫類型對象-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jdbc</artifactId>
            </dependency>
           <!--反應式web框架-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-webflux</artifactId>
            </dependency>
    

    MySQL版本為5.7,沒有測試其它版本。

    3. R2DBC配置

    所有的R2DBC自動配置都在org.springframework.boot.autoconfigure.data.r2dbc包下,如果要配置MySQL必須針對性的配置對應的連接工廠接口ConnectionFactory,當然也可以通過application.yml配置。個人比較喜歡JavaConfig

    @Bean
    ConnectionFactory connectionFactory() {
        return MySqlConnectionFactory.from(MySqlConnectionConfiguration.builder()
                .host("127.0.0.1")
                .port(3306)
                .username("root")
                .password("123456")
                .database("database_name")
                 // 額外的其它非必選參數省略                          
                .build());
    }
    

    詳細配置可參考r2dbc-mysql的官方說明:https://github.com/mirromutth/r2dbc-mysql

    ConnectionFactory配置好后,就會被注入DatabaseClient 對象。該對象是非阻塞的,用於執行數據庫反應性客戶端調用與反應流背壓請求。我們可以通過該接口反應式地操作數據庫。

    4. 編寫反應式接口

    我們先創建一張表並寫入一些數據:

    create table client_user
    (
        user_id         varchar(64)                              not null comment '用戶唯一標示' primary key,
        username        varchar(64)                              null comment '名稱',
        phone_number    varchar(64)                              null comment '手機號',
        gender          tinyint(1) default 0                     null comment '0 未知 1 男 2 女  '
    )
    

    對應的實體為:

    package cn.felord.r2dbc.config;
    
    import lombok.Data;
    
    /**
     * @author felord.cn
     */
    @Data
    public class ClientUser {
    
        private String userId;
        private String username;
        private String phoneNumber;
        private Integer gender;
    }
    

    然後我們編寫一個Webflux的反應式接口:

    package cn.felord.r2dbc.config;
    
    import org.springframework.data.r2dbc.core.DatabaseClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Flux;
    import reactor.core.publisher.Mono;
    
    import javax.annotation.Resource;
    
    /**
     * The type User controller.
     *
     * @author felord.cn
     * @since 17 :07
     */
    @RestController
    @RequestMapping("/user")
    public class UserController {
        @Resource
        private DatabaseClient databaseClient;
    
        /**
         * 查詢
         *
         * @return 返回Flux序列 包含所有的ClientUser
         */
        @GetMapping("/get")
        public Flux<ClientUser> clientUserFlux() {
            return databaseClient.execute("select * from client_user").as(ClientUser.class)
                    .fetch()
                    .all();
        }
    
        /**
         * 響應式寫入.
         *
         * @return Mono對象包含更新成功的條數
         */
        @GetMapping("/add")
        public Mono<Integer> insert() {
            ClientUser clientUser = new ClientUser();
            clientUser.setUserId("34345514644");
            clientUser.setUsername("felord.cn");
            clientUser.setPhoneNumber("3456121");
            clientUser.setGender(1);
    
            return databaseClient.insert().into(ClientUser.class)
                    .using(clientUser)
                    .fetch().rowsUpdated();
        }
    
    }
    

    調用接口就能獲取到期望的數據結果。

    5. 總結

    乍一看R2DBC並沒有想象中的那麼難,但是間接的需要了解FluxMono等抽象概念。同時目前來說如果不和Webflux框架配合也沒有使用場景。就本文的MySQL而言,R2DBC驅動還是社區維護(不得不說PgSQL就做的很好)。

    然而需要你看清的是反應式才是未來。如果你要抓住未來就需要現在就了解一些相關的知識。這讓我想起五年前剛剛接觸Spring Boot的感覺。另外這裡有一份Spring官方關於R2DBC的PPT,也是讓你更好了解R2DBC的權威資料。可以關注:碼農小胖哥 回復r2dbc獲取。

    關注公眾號:Felordcn 獲取更多資訊

    個人博客:https://felord.cn

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

    【其他文章推薦】

    新北清潔公司,居家、辦公、裝潢細清專業服務

    ※別再煩惱如何寫文案,掌握八大原則!

    網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

    ※超省錢租車方案

    ※教你寫出一流的銷售文案?