分類: 3C資訊

  • 【離散優化】覆蓋問題

    覆蓋問題

    我們知道設施選址問題有兩類基礎問題,分別是中值問題和覆蓋問題,下面要介紹的就是覆蓋問題。

    什麼是覆蓋問題?

    覆蓋問題是以所期望的服務範圍滿足大多數或者所有用戶需求為前提,確定設施的位置。覆蓋模型的思想是離服務設施較近的用戶越多,則服務越好。

    覆蓋問題的分類

    覆蓋問題主要分為兩類:

    • 集合覆蓋問題(Location Set Covering Problem,LSCP)
    • 最大覆蓋問題(Maximum Covering Location Problem,MCLP)

    覆蓋模型常用於哪些場景?

    由於 P-中值模型常以總距離或者總時間作為測度指標,使得其並不適用於一些特殊的場景,比如消防中心和救護車等應急設施的區位選址問題,而覆蓋模型則比較適用於這些場景。

    如何定義覆蓋?

    如果需求點 \(i\) 到備選設施點 \(j\) 的距離或者時間小於臨界值 \(D_c\),那麼稱需求點 \(i\) 被候選設施點 \(j\) 覆蓋。、

    下面介紹兩類覆蓋問題的數學模型表達

    集合覆蓋問題 (Location Set Covering Problem,LSCP)

    目標函數:

    \[\min \sum_{j \in J}x_j \]

    約束:

    \[\sum_{j \in N_i} x_j \geqslant 1 \quad \forall i \in I \tag{c-1} \]

    \[x_j \in \{0, 1\} \quad \forall j \in J \tag{c-2} \]

    其中,

    • \(N_i = \{j:a_{ij}=1\}\) 是覆蓋需求點 \(i\) 的候選設施點的集合,變量 \(a_{ij}\) 用來判斷需求點 \(i\) 是否被候選設施點 \(j\) 覆蓋,若是,則 \(a_{ij}=1\),否則 \(a_{ij}=0\)
    • 目標函數旨在尋求設施總量最小
    • 約束 \(c-1\) 保證每個需求點至少被一個設施服務範圍所覆蓋
    • 約束 \(c-2\) 是決策變量的取值範圍

    在某些場景中,集合覆蓋問題有以下兩個缺點:

    • 為了保證所有需求點均被覆蓋而引入過多的設施,以至於超出預算
    • 模型無法區分需求點的需求強度

    現實生活中,常常由於預算或者資源的約束,有限的設施不能保證空間中所有需求點都被覆蓋,此時,優先考慮需求強度大的需求點是十分必要的,下面要介紹的最大覆蓋模型就是為了解決這個問題而被提出。

    最大覆蓋問題(Maximum Covering Location Problem,MCLP)

    目標函數

    \[\max \sum_{i \in N_i} \omega_iz_i \]

    約束

    \[z_i \leqslant \sum_{j \in N_i}x_j \quad \forall i \in I \tag{c-1} \]

    \[\sum_{j\in J}x_j = p \tag{c-2} \]

    \[x_j \in \{0,1\} \quad \forall j \in J \tag{c-3} \]

    \[z_i = \{0, 1\} \quad \forall i \in I \tag{c-4} \]

    其中,

    • \(\omega_i\) 為需求點 \(i\) 的需求強度

    • \(z_i\) 用來判斷需求點 \(i\) 是否被覆蓋,若覆蓋,則為 1,否則為 0

    • 目標函數旨在尋求有限設施(\(p\) 個)覆蓋的需求最多

    • 約束 \(c-1\) 要求除非在備選設施點中已定位一個設施可以覆蓋需求點 \(i\),否則需求點 \(i\) 將不被記作被覆蓋

    • 約束 \(c-2\) 限制設施的總數為 \(p\)

    • 約束 \(c-3, c-4\) 是決策變量的取值範圍

    更多種類的選址問題

    以上介紹的覆蓋問題的基礎模型框架,然而具體問題一般是較為複雜的設施選址問題,這就需要我們對基礎模型設置不同的條件從而進行擴展,比如:

    • 用於環境污染防治的鄰避型設施選址問題
    • 用於不同服務等級的層次型設置選址問題
    • 用於商業競爭的競爭型設施選址問題
    • 選址問題也開始考慮動態、不確定性等因素

    總結

    總結以上兩類問題,我們可以發現最大覆蓋模型和集合覆蓋模型的主要區別在於對設施數量和需求強度的關注不同,前者一般適用於建設經費充足或者設施成本相同的情況,後者則適用於有設施成本約束的選址決策。

    參考文獻

    本文內容主要從論文《設施選址問題中的基礎模型與求解方法比較》總結而來。

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

    【其他文章推薦】

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

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

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

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

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

    ※超省錢租車方案

  • 記一次uboot升級過程的兩個坑

    記一次uboot升級過程的兩個坑

    背景

    之前做過一次uboot的升級,當時留下了一些記錄,本文摘錄其中比較有意思的兩個問題。

    啟動失敗問題

    問題簡述

    uboot代碼中用到了一個庫,考慮到庫本身跟uboot版本沒什麼關係,就直接把舊的庫文件拷貝過來使用。結果編譯鏈接是沒問題,啟動卻會卡住。

    消失的打印

    為了明確卡住的位置,就去修改了庫的源碼,添加一些打印(此時還是在舊版本uboot下編譯的),結果發現卡住的位置或隨着添加打印的變化而變化,且有些打印語句,添加后未打印出來。

    我決定先從這些神秘消失的打印入手。

    分析下uboot中的printf實現,最底層就是寫寄存器,是一個同步的函數,也沒什麼可疑的地方。

    為了確認打印不出來的時候,到底有沒有調用到printf,我決定給printf增加一個計數器,在gd結構體中,增加一個printf_count字段,初始化為0,每次打印時執行printf_count++並打印出值。

    設計這個試驗,本意是確認未打印出來時是否確實也調用到了printf,但卻有了別的發現,實驗結果中printf_count值會異常變化,不是按打印順序遞增,而是會突變成很大的異常值。

    printf_countgd結構體的成員,那就是gd的問題了。進一步將uboot全局結構體gd的地址打印出來。確認了原因是gd結構體的指針變化了。

    這也可以解釋部分打印消失的現象,原因是我們在gd中有另一個字段,用於控制打印等級。當gd被改動了,printf就可能解析出錯,誤以為打印等級為0而提前返回。

    gd的實現

    那麼好端端的,gd為什麼會被改了呢?這就要先看看gd到底是怎麼實現的了。

    uboot中維護了一個全局的結構體gd。在代碼中加入

    DECLARE_GLOBAL_DATA_PTR;
    

    即可使用gd指針訪問這個全局結構體,許多地方都會藉助gd來保存傳遞信息。

    進一步看看這個宏的定義

    舊版本uboot:
    #define DECLARE_GLOBAL_DATA_PTR        register volatile gd_t *gd asm ("r8")
    
    新版本uboot:
    #define DECLARE_GLOBAL_DATA_PTR        register volatile gd_t *gd asm ("r9")
    

    居然不一樣,一個是將gd的值放到r8寄存器,一個是放在r9寄存器。

    那麼就可以猜測到,庫是在舊版本uboot中編譯出來的,可能使用了r9,那麼放到新版本uboot中去,就會破壞r9寄存器中保存的gd值,導致一系列依賴gd的代碼不能正常工作。

    驗證改動

    為了求證,將庫反彙編出來,發現確實避開了r8寄存器,但使用了r9寄存器。

    說明uboot在指定gd寄存器的同時,還有某種方法讓其他代碼不使用這個寄存器。

    那是不是把舊uboot中的這個r8改成r9,重新編譯庫就可以了呢?試一下,還是不行。

    那麼禁止其他代碼使用r8寄存器肯定就是通過別的方式實現的了。簡單粗暴地在舊版本uboot下搜索r8,去掉.c .h等類型后,很容易發現了

    ./arch/arm/cpu/armv7/config.mk:24:PLATFORM_RELFLAGS += -fno-common -ffixed-r8 -msoft-floa
    

    -ffixed-r8修改為-ffixed-r9,重新編譯出庫,這回就可以正常工作了,打印正常,啟動正常。反彙編出來也可以看到,新編譯出來的庫用了r8沒有用r9

    當然更好的改法,是直接在新版本的uboot中編譯,這是最可靠的。

    追本溯源

    話說回來,為什麼兩個版本的uboot,會使用不同的寄存器呢?難道有什麼坑?

    這就得去翻一下git記錄了。

    commit fe1378a961e508b31b1f29a2bb08ba1dac063155
    Author: Jeroen Hofstee <jeroen@myspectrum.nl>
    Date:   Sat Sep 21 14:04:41 2013 +0200
    
        ARM: use r9 for gd
        
        To be more EABI compliant and as a preparation for building
        with clang, use the platform-specific r9 register for gd
        instead of r8.
        
        note: The FIQ is not updated since it is not used in u-boot,
        and under discussion for the time being.
        
        The following checkpatch warning is ignored:
        WARNING: Use of volatile is usually wrong: see
        Documentation/volatile-considered-harmful.txt
        
        Signed-off-by: Jeroen Hofstee <jeroen@myspectrum.nl>
        cc: Albert ARIBAUD <albert.u.boot@aribaud.net>
    

    git記錄中,也可以確認完整地將r8切換到r9,都需要做哪些修改

    diff --git a/arch/arm/config.mk b/arch/arm/config.mk
    index 16c2e3d1e0..d0cf43ff41 100644
    --- a/arch/arm/config.mk
    +++ b/arch/arm/config.mk
    @@ -17,7 +17,7 @@ endif
     
     LDFLAGS_FINAL += --gc-sections
     PLATFORM_RELFLAGS += -ffunction-sections -fdata-sections \
    -                     -fno-common -ffixed-r8 -msoft-float
    +                     -fno-common -ffixed-r9 -msoft-float
     
     # Support generic board on ARM
     __HAVE_ARCH_GENERIC_BOARD := y
    diff --git a/arch/arm/cpu/armv7/lowlevel_init.S b/arch/arm/cpu/armv7/lowlevel_init.S
    index 82b2b86520..69e3053a42 100644
    --- a/arch/arm/cpu/armv7/lowlevel_init.S
    +++ b/arch/arm/cpu/armv7/lowlevel_init.S
    @@ -22,11 +22,11 @@ ENTRY(lowlevel_init)
            ldr     sp, =CONFIG_SYS_INIT_SP_ADDR
            bic     sp, sp, #7 /* 8-byte alignment for ABI compliance */
     #ifdef CONFIG_SPL_BUILD
    -       ldr     r8, =gdata
    +       ldr     r9, =gdata
     #else
            sub     sp, #GD_SIZE
            bic     sp, sp, #7
    -       mov     r8, sp
    +       mov     r9, sp
     #endif
            /*
             * Save the old lr(passed in ip) and the current lr to stack
    diff --git a/arch/arm/include/asm/global_data.h b/arch/arm/include/asm/global_data.h
    index 79a9597419..e126436093 100644
    --- a/arch/arm/include/asm/global_data.h
    +++ b/arch/arm/include/asm/global_data.h
    @@ -47,6 +47,6 @@ struct arch_global_data {
     
     #include <asm-generic/global_data.h>
     
    -#define DECLARE_GLOBAL_DATA_PTR     register volatile gd_t *gd asm ("r8")
    +#define DECLARE_GLOBAL_DATA_PTR     register volatile gd_t *gd asm ("r9")
     
     #endif /* __ASM_GBL_DATA_H */
    diff --git a/arch/arm/lib/crt0.S b/arch/arm/lib/crt0.S
    index 960d12e732..ac54b9359a 100644
    --- a/arch/arm/lib/crt0.S
    +++ b/arch/arm/lib/crt0.S
    @@ -69,7 +69,7 @@ ENTRY(_main)
            bic     sp, sp, #7      /* 8-byte alignment for ABI compliance */
            sub     sp, #GD_SIZE    /* allocate one GD above SP */
            bic     sp, sp, #7      /* 8-byte alignment for ABI compliance */
    -       mov     r8, sp          /* GD is above SP */
    +       mov     r9, sp          /* GD is above SP */
            mov     r0, #0
            bl      board_init_f
     
    @@ -81,15 +81,15 @@ ENTRY(_main)
      * 'here' but relocated.
      */
     
    -       ldr     sp, [r8, #GD_START_ADDR_SP]     /* sp = gd->start_addr_sp */
    +       ldr     sp, [r9, #GD_START_ADDR_SP]     /* sp = gd->start_addr_sp */
            bic     sp, sp, #7      /* 8-byte alignment for ABI compliance */
    -       ldr     r8, [r8, #GD_BD]                /* r8 = gd->bd */
    -       sub     r8, r8, #GD_SIZE                /* new GD is below bd */
    +       ldr     r9, [r9, #GD_BD]                /* r9 = gd->bd */
    +       sub     r9, r9, #GD_SIZE                /* new GD is below bd */
     
            adr     lr, here
    -       ldr     r0, [r8, #GD_RELOC_OFF]         /* r0 = gd->reloc_off */
    +       ldr     r0, [r9, #GD_RELOC_OFF]         /* r0 = gd->reloc_off */
            add     lr, lr, r0
    -       ldr     r0, [r8, #GD_RELOCADDR]         /* r0 = gd->relocaddr */
    +       ldr     r0, [r9, #GD_RELOCADDR]         /* r0 = gd->relocaddr */
            b       relocate_code
     here:
     
    @@ -111,8 +111,8 @@ clbss_l:cmp r0, r1                  /* while not at end of BSS */
            bl red_led_on
     
            /* call board_init_r(gd_t *id, ulong dest_addr) */
    -       mov     r0, r8                  /* gd_t */
    -       ldr     r1, [r8, #GD_RELOCADDR] /* dest_addr */
    +       mov     r0, r9                  /* gd_t */
    +       ldr     r1, [r9, #GD_RELOCADDR] /* dest_addr */
            /* call board_init_r */
            ldr     pc, =board_init_r       /* this is auto-relocated! */
    

    啟動慢問題

    問題簡述

    填了幾個坑之後,新的uboot可以啟動到內核了,但發現啟動速度非常慢,內核啟動速度慢了接近10倍!明明是同一個內核,為什麼差異這麼大。

    排查寄存器

    初步排查了下設備樹配置,以及uboot跳轉內核前的一些關鍵寄存器,確實在兩個版本的uboot中有所不同,但具體去看這些不同,發現都不會影響速度,將一些驅動對齊之後寄存器差異基本就消失了。

    差異的分界

    那再細看,kernel的速度有差異,uboot呢?在哪個時間點之後,速度開始產生差異?

    嘗試在兩個版本的uboot中插入一些操作,對比時間戳,發現兩個uboot在某個節點之後的速度確實有區別。

    進一步排查,原來是在打開cache操作之後,舊uboot的速度就會比新uboot快。嘗試將舊ubootcache關掉,則二者基本一致。嘗試將舊uboot操作cache的代碼,移植到新uboot,未發生改變。

    此時可確認新uboot的開cache有問題。但覺得這個跟kernel啟動慢沒關係。因為uboot進入kernel之前都會關cache,由kernel自己去重新打開。

    也就是不管是用哪份uboot,也不管uboot中是否開了cache,對kernel階段都應該沒有影響才對。

    於是記錄下來uboot的這個問題,待後續修復。先繼續找kernel啟動慢的原因。(注:現在看來當時的做法是有問題的,這裏的異常這麼明顯,應該設法追蹤下去找出原因才對)

    鎖定uboot

    uboot的嫌疑非常大,但還不能完全確認,因為uboot之前還有一級spl。是否會是spl的問題呢?

    嘗試改用新spl+舊uboot,啟動速度正常。而新spl+新uboot的啟動速度則很慢,其他因素都不變,說明問題確實出在uboot階段。

    多做or少做

    當時到這一步就卡住了,直接比較兩份uboot的代碼不太現實,差異太大了。

    後來我就給自己提了個問題,到底新uboot是多做了某件事情,還是少做了某件事情?

    換個說法,目前已知

    spl --> 舊uboot --> kernel(速度快)
    spl --> 新uboot --> kernel(速度快)
    

    但到底是以下的情況A還是情況B呢?

    A: spl(速度慢) --> 舊uboot(做了某個會提升速度的操作) --> kernel(速度快)
       spl(速度慢) --> 新uboot(少做了某個會提升速度的操作) --> kernel(速度慢)
    
    B: spl(速度快) --> 舊uboot(沒做特殊操作) --> kernel(速度快)
       spl(速度快) --> 新uboot(多做了某個會限制速度的操作) --> kernel(速度慢)
    

    為了驗證,我決定讓spl直接啟動內核,看看內核到底是快是慢。

    支持過程碰到了一些小問題

    1.spl沒有能力加載這麼大的kernel

    解決:此時不需要kernel能完全啟動,只需要能加載啟動一段,足以體現出啟動速度是否正常即可,於是裁剪出一個非常小kernel來輔助實驗。

    2.kernel需要dtb

    解決:內核有一個CONFIG_BUILD_ARM_APPENDED_DTB_IMAGE選項。選上重新編譯。編譯后再用ddkerneldtb拼接到一起,作為新的kernel。這樣,spl就只需要加載一個文件並跳轉過去即可。

    試驗結果,spl啟動的kernel和使用新uboot啟動的kernel速度一致,均比舊uboot啟動的kernel慢。

    說明,舊uboot中做了某個關鍵操作,而新uboot沒做。

    找出關鍵操作

    那接下來的任務就是,找出舊uboot中的這個關鍵操作了。

    怎麼找呢?有了上一步的成果,我們可以使用以下方法來排查

    1. spl加載kernel和舊uboot

    2. spl跳轉到舊uboot,此時kernel其實已經在dram中準備好了,隨時可以啟動

    3. 在舊uboot的啟動流程各個階段,嘗試直接跳轉到kernel,觀察啟動速度

    4. 如果在舊ubootA點跳轉kernel啟動慢,B點跳轉啟動快,則說明關鍵操作位於AB點之間。

    方法有了,很快就鎖定到start.S,進一步在start.S中揪出了這段代碼

    #if defined(CONFIG_ARM_A7)
    @set SMP bit
        mrc     p15, 0, r0, c1, c0, 1
        orr        r0, r0, #(1<<6)
        mcr        p15, 0, r0, c1, c0, 1
    #endif
    

    ubootstart.S中沒有這段代碼,嘗試在新ubootstart.S中添加此操作,速度立馬恢復正常了。

    再全局搜索下,原來這個新版本uboot中,套路是在board_init中進行此項設置的,而這個平台從舊版本移植過來,就沒有設置 SMP bit, 補上即可。

    SMP bit是什麼

    SMP 是指對稱多處理器,看起來這個 bit 會影響多核的 cache一致性,此處沒有再深入研究。

    但可以知道,對於單處理器的情況,也需要設置這個bit才能正常使用cache

    貼下arm的圖和描述:

    [6]	SMP	
    
    Signals if the Cortex-A9 processor is taking part in coherency or not.
    
    In uniprocessor configurations, if this bit is set, then Inner Cacheable Shared is treated as Cacheable. The reset value is zero.
    

    搜下kernel的代碼,發現也是有地方調用了的。不過這個芯片是單核的,根本就沒配置CONFIG_SMP

    #ifdef CONFIG_SMP
    	ALT_SMP(mrc	p15, 0, r0, c1, c0, 1)
    	ALT_UP(mov	r0, #(1 << 6))		@ fake it for UP
    	tst	r0, #(1 << 6)			@ SMP/nAMP mode enabled?
    	orreq	r0, r0, #(1 << 6)		@ Enable SMP/nAMP mode
    	orreq	r0, r0, r10			@ Enable CPU-specific SMP bits
    	mcreq	p15, 0, r0, c1, c0, 1
    #endif
    

    總結

    整理出來一方面是記錄這兩個bug,另一方面也是想記錄下當時的一些操作。

    畢竟同樣的bug可能以後都不會碰到了,但解bug的方法和思路卻是可以積累復用的。

    blog: https://www.cnblogs.com/zqb-all/p/13172546.html
    公眾號:https://sourl.cn/shT3kz

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

    【其他文章推薦】

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

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

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

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

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

    網頁設計最專業,超強功能平台可客製化

  • Python 為什麼不支持 i++ 自增語法,不提供 ++ 操作符?

    Python 為什麼不支持 i++ 自增語法,不提供 ++ 操作符?

    在 C/C++/Java 等等語言中,整型變量的自增或自減操作是標配,它們又可分為前綴操作(++i 和 –i)與後綴操作(i++ 和 i–),彼此存在着一些細微差別,各有不同的用途。

    這些語言的使用者在接觸 Python 時,可能會疑惑為什麼它不提供 ++ 或 — 的操作呢?在我前不久發的《Python的十萬個為什麼?》里,就有不少同學在調查問卷中表示了對此話題感興趣。

    Python 中雖然可能出現 ++i 這種前綴形式的寫法,但是它並沒有“++”自增操作符,此處只是兩個“+”(正數符號)的疊加而已,至於後綴形式的“++”,則完全不支持(SyntaxError: invalid syntax)。

    本期“Python為什麼 ”欄目,我們將會從兩個主要的角度來回答:Python 為什麼不支持 i++ 自增語法? (PS:此處自增指代“自增和自減”,下同)

    首先,Python 當然可以實現自增效果,即寫成i += 1 或者 i = i + 1 ,這在其它語言中也是通用的。

    雖然 Python 在底層用了不同的魔術方法(__add__()__iadd__() )來完成計算,但表面上的效果完全相同。

    所以,我們的問題可以轉化成:為什麼上面的兩種寫法會勝過 i++,成為 Python 的最終選擇呢?

    1、Python 的整數是不可變類型

    當我們定義i = 1000 時,不同語言會作出不同的處理:

    • C 之類的語言(寫法 int i = 1000)會申請一塊內存空間,並給它“綁定”一個固定的名稱 i,同時寫入一個可變的值 1000。在這裏,i 的地址以及類型是固定的,而值是可變的(在一定的表示範圍內)
    • Python(寫法i = 1000)也會申請一塊內存空間,但是它會“綁定”給数字 1000,即這個 1000 的地址以及類型是固定的(immutable),至於 i,只是一個名稱標籤貼在 1000 上,自身沒有固定的地址和類型

    所以當我們令 i “自增”時(i = i + 1),它們的處理是不同的:

    • C 之類的語言先找到 i 的地址上存的數值,然後令它加 1,操作后新的數值就取代了舊的數值
    • Python 的操作過程是把 i 指向的数字加 1,然後把結果綁定到新申請的一塊內存空間,再把名稱標籤 i “貼”到新的数字上。新舊数字可以同時存在,不是取代關係

    打一個不太恰當的比方:C 中的 i 就像一個宿主,数字 1000 寄生在它上面;而 Python 中的 1000 像個宿主,名稱 i 寄生在它上面。C 中的 i 與 Python 中的 1000,它們則寄生在底層的內存空間上……

    還可以這樣理解:C 中的變量 i 是一等公民,数字 1000 是它的一個可變的屬性;Python 中的数字 1000 是一等公民,名稱 i 是它的一個可變的屬性。

    有了以上的鋪墊,我們再來看看 i++,不難發現:

    • C 之類的語言,i++ 可以表示 i 的数字屬性的增加,它不會開闢新的內存空間,也不會產生新的一等公民
    • Python 之類的語言,i++ 如果是對其名稱屬性的操作,那樣就沒有意義了(總不能按字母表順序,把 i 變成 j 吧);如果理解成對数字本體的操作,那麼情況就會變得複雜:它會產生新的一等公民 1001,因此需要給它分配一個內存地址,此時若佔用 1000 的地址,則涉及舊對象的回收,那原有對於 1000 的引用關係都會受到影響,所以只能開闢新的內存空間給 1001

    Python 若支持 i++,其操作過程要比 C 的 i++ 複雜,而且其含義也不再是“令数字增加1”(自增),而是“創建一個新的数字”(新增), 這樣的話,“自增操作符”(increment operator)就名不副實了。

    Python 在理論上可以實現 i++ 操作,但它就必須重新定義“自增操作符”,還會令有其它語言經驗的人產生誤解,不如就讓大家直接寫成i += 1 或者 i = i + 1 好了。

    2、Python 有可迭代對象

    C/C++ 等語言設計出 i++,最主要的目的是為了方便使用三段式的 for 結構:

    for(int i = 0; i < 100; i++){
        // 執行 xxx
    }
    

    這種程序關心的是数字本身的自增過程,数字做加法與程序體的執行相關聯。

    Python 中沒有這種 for 結構的寫法,它提供了更為優雅的方式:

    for i in range(100):
        # 執行 xxx
    
    my_list = ["你好", "我是Python貓", "歡迎關注"]
    for info in my_list:
        print(info)
    

    這裏體現了不同的思維方式,它關心的是在一個數值範圍內的迭代遍歷,並不關心也不需要人為對数字做加法。

    Python 中的可迭代對象/迭代器/生成器提供了非常良好的迭代/遍歷用法,能夠做到對 i++ 的完全替代。

    例如,上例中實現了對列表內值的遍歷,Python 還可以用 enumerate() 實現對下標與具體值的同時遍歷:

    my_list = ["你好", "我是Python貓", "歡迎關注"]
    for i, info in enumerate(my_list):
        print(i, info)
    
    # 打印結果:
    0 你好
    1 我是Python貓
    2 歡迎關注
    

    再例如對於字典的遍歷,Python 提供了 keys()、values()、items() 等遍歷方法,非常好用:

    my_dict = {'a': '1', 'b': '2', 'c': '3'}
    for key in my_dict.keys():
        print(key)
    
    for key, value in my_dict.items():
        print(key, value)
    

    有了這樣的利器,哪裡還有 i++ 的用武之地呢?

    不僅如此,Python 中基本上很少使用i += 1 或者 i = i + 1 ,由於存在着隨處可見的可迭代對象,開發者們很容易實現對一個數值區間的操作,也就很少有對於某個數值作累加的訴求了。

    所以,回到我們開頭的問題,其實這兩種“自增”寫法並沒有勝出 i++ 多少,只因為它們是通用型操作,又不需要引入新的操作符,所以 Python 才延續了一種基礎性的支持。真正的贏家其實是各種各樣的可迭代對象!

    稍微小結下:Python 不支持自增操作符,一方面是因為它的整數是不可變類型的一等公民,自增操作(++)若要支持,則會帶來歧義;另一方面主要因為它有更合適的實現,即可迭代對象,對遍歷操作有很好的支持。

    如果你覺得本文分析得不錯,那你應該會喜歡這些文章:

    1、Python為什麼使用縮進來劃分代碼塊?

    2、Python 的縮進是不是反人類的設計?

    3、Python 為什麼不用分號作語句終止符?

    4、Python 為什麼沒有 main 函數?為什麼我不推薦寫 main 函數?

    5、Python 為什麼推薦蛇形命名法?

    寫在最後:本文屬於“Python為什麼”系列(Python貓出品),該系列主要關注 Python 的語法、設計和發展等話題,以一個個“為什麼”式的問題為切入點,試着展現 Python 的迷人魅力。部分話題會推出視頻版,請在 B 站收看,觀看地址:視頻地址

    公眾號【Python貓】, 本號連載優質的系列文章,有Python為什麼系列、喵星哲學貓系列、Python進階系列、好書推薦系列、技術寫作、優質英文推薦與翻譯等等,歡迎關注哦。

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

    【其他文章推薦】

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

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

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

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

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

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

  • 手把手教你學Numpy,搞定數據處理——收官篇

    手把手教你學Numpy,搞定數據處理——收官篇

    本文始發於個人公眾號:TechFlow,原創不易,求個關注

    今天是Numpy專題第6篇文章,我們一起來看看Numpy庫當中剩餘的部分。

    數組的持久化

    在我們做機器學習模型的研究或者是學習的時候,在完成了訓練之後,有時候會希望能夠將相應的參數保存下來。否則的話,如果是在Notebook當中,當Notebook關閉的時候,這些值就丟失了。一般的解決方案是將我們需要的值或者是數組“持久化”,通常的做法是存儲在磁盤上。

    Python當中讀寫文件稍稍有些麻煩,我們還需要創建文件句柄,然後一行行寫入,寫入完成之後需要關閉句柄。即使是用with語句,也依然不夠簡便。針對這個問題,numpy當中自帶了寫入文件的api,我們直接調用即可。

    通過numpy當中save的文件是二進制格式的,所以我們是無法讀取其中內容的,即使強行打開也會是亂碼。

    以二進制的形式存儲數據避免了數據類型轉化的過程,尤其是numpy底層的數據是以C++實現的,如果使用Python的文件接口的話,勢必要先轉化成Python的格式,這會帶來大量開銷。既然可以存儲,自然也可以讀取,我們可以調用numpy的load函數將numpy文件讀取進來。

    要注意我們保存的時候沒有添加文件後綴,numpy會自動為我們添加後綴,但是讀取的時候必須要指定文件的全名,否則會numpy無法找到,會引發報錯。

    不僅如此,numpy還支持我們同時保存多個數組進入一個文件當中。

    我們使用savez來完成,在這個api當中我們傳入了a=arr,b=arr,其實是以類似字典的形式傳入的。在文件當中,numpy會將變量名和數組的值映射起來。這樣我們在讀入的時候,就可以通過變量名訪問到對應的值了。

    如果要存儲的數據非常大的話,我們還可以對數據進行壓縮,我們只需要更換savez成savez_compressed即可。

    線性代數

    Numpy除了科學計算之外,另外一大強大的功能就是支持矩陣運算,這也是它廣為流行並且在機器學習當中大受歡迎的原因之一。我們在之前的線性代數的文章當中曾經提到過Numpy這方面的一些應用,我們今天再在這篇文章當中匯總一些常用的線性代數的接口。

    點乘

    說起來矩陣點乘應該是最常用的線代api了,比如在神經網絡當中,如果拋開激活函數的話,一層神經元對於當前數據的影響,其實等價於特徵矩陣點乘了一個係數矩陣。再比如在邏輯回歸當中,我們計算樣本的加權和的時候,也是通過矩陣點乘來實現的。

    在Andrew的深度學習課上,他曾經做過這樣的實現,對於兩個巨大的矩陣進行矩陣相乘的運算。一次是通過Python的循環來實現,一次是通過Numpy的dot函數實現,兩者的時間開銷相差了足足上百倍。這當中的效率差距和Python語言的特性以及併發能力有關,所以在機器學習領域當中,我們總是將樣本向量化或者矩陣化,通過點乘來計算加權求和,或者是係數相乘。

    在Numpy當中我們採用dot函數來計算兩個矩陣的點積,既可以寫成a.dot(b),也可以寫成np.dot(a, b)。一般來說我更加喜歡前者,因為寫起來更加方便清晰。如果你喜歡後者也問題不大,這個只是個人喜好。

    注意不要寫成*,這個符號代表兩個矩陣元素兩兩相乘,而不是進行點積運算。它等價於np當中的multiply函數。

    轉置與逆矩陣

    轉置我們曾經在之前的文章當中提到過,可以通過.T或者是np.transpose來完成。

    Numpy中還提供了求解逆矩陣的操作,這個函數在numpy的linalg路徑下,這個路徑下實現了許多常用的線性代數函數。根據線性代數當中的知識,只有滿秩的方陣才有逆矩陣。我們可以通過numpy.linalg.det先來計算行列式來判斷,否則如果直接調用的話,對於沒有逆矩陣的矩陣會報錯。

    在這個例子當中,由於矩陣b的行列式為0,說明它並不是滿秩的,所以我們求它的逆矩陣會報錯。

    除了這些函數之外,linalg當中還封裝了其他一些常用的函數。比如進行qr分解的qr函數,進行奇異值分解的svd函數,求解線性方程組的solve函數等。相比之下,這些函數的使用頻率相對不高,所以就不展開一一介紹了,我們可以用到的時候再去詳細研究。

    隨機

    Numpy當中另外一個常用的領域就是隨機數,我們經常使用Numpy來生成各種各樣的隨機數。這一塊在Numpy當中其實也有很多的api以及很複雜的用法,同樣,我們不過多深入,挑其中比較重要也是經常使用的和大家分享一下。

    隨機數的所有函數都在numpy.random這個路徑下,我們為了簡化,就不寫完整的路徑了,大家記住就好。

    randn

    這個函數我們經常在代碼當中看到,尤其是我們造數據的時候。它代表的是根據輸入的shape生成一批均值為0,標準差為1的正態分佈的隨機數。

    要注意的是,我們傳入的shape不是一個元組,而是每一維的大小,這一點和其他地方的用法不太一樣,需要注意一下。除了正態分佈的randn之外,還有均勻分佈的uniform和Gamma分佈的gamma,卡方分佈的chisquare。

    normal

    normal其實也是生成正態分佈的樣本值,但不同的是,它支持我們指定樣本的均值和標準差。如果我們想要生成多個樣本,還可以在size參數當中傳入指定的shape。

    randint

    顧名思義,這個函數是用來生成隨機整數的。它接受傳入隨機數的上下界,最少也要傳入一個上界(默認下界是0)。

    如果想要生成多個int,我們可以在size參數傳入一個shape,它會返回一個對應大小的數組,這一點和uniform用法一樣。

    shuffle

    shuffle的功能是對一個數組進行亂序,返回亂序之後的結果。一般用在機器學習當中,如果存在樣本聚集的情況,我們一般會使用shuffle進行亂序,避免模型受到樣本分佈的影響。

    shuffle是一個inplace的方法,它會在原本值上進行改動,而不會返回一個新值。

    choice

    這也是一個非常常用的api,它可以在數據當中抽取指定條數據。

    但是它只支持一維的數組,一般用在批量訓練的時候,我們通過choice採樣出樣本的下標,再通過數組索引去找到這些樣本的值。比如這樣:

    總結

    今天我們一起研究了Numpy中數據持久化、線性代數、隨機數相關api的使用方法,由於篇幅的限制,我們只是選擇了其中比較常用,或者是比較重要的用法,還存在一些較為冷門的api和用法,大家感興趣的可以自行研究一下,一般來說文章當中提到的用法已經足夠了。

    今天這篇是Numpy專題的最後一篇了,如果你堅持看完本專題所有的文章,那麼相信你對於Numpy包一定有了一個深入的理解和認識了,給自己鼓鼓掌吧。之後周四會開啟Pandas專題,敬請期待哦。

    如果喜歡本文,可以的話,請點個關注,給我一點鼓勵,也方便獲取更多文章。

    本文使用 mdnice 排版

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

    【其他文章推薦】

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

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

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

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

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

    ※產品缺大量曝光嗎?你需要的是一流包裝設計!

  • JAVA設計模式 2【創建型】原型模式的理解與使用、理解淺克隆和深克隆

    JAVA設計模式 2【創建型】原型模式的理解與使用、理解淺克隆和深克隆

    在本節中,我們將學習和使用原型模式;這一節學習的原型模式也是創建型 模式的其中之一。再次複習一下:創建型 模式就是描述如何去更好的創建一個對象。

    我們都知道,在JAVA 語言中。使用new 關鍵字創建一個新對象。將新的對象放到堆內存 裏面。當然,這個內存肯定是有大小限制的,況且,JAVA 不同於C語言等。 有內存管理機制,就是我們常說的垃圾回收器GC,才可以保證內存不被溢出。

    說這些其實就是為了表示:為啥要用單例模式,能節省內存的時候,能用一個對象解決重複的事情,絕對不會創建多個。

    概述

    原型模式描述的如何快速創建重複的對象,並且減少new 關鍵字的使用。

    • 抽象原型類
    • 具體原型類
    • 訪問類

    容我來一個一個解釋:

    抽象原型類 也就是我們具體要實現的某個類,這個類在JAVA 裏面是有具體的接口的,其實是一個空接口,Cloneable

     * @author  unascribed
     * @see     java.lang.CloneNotSupportedException
     * @see     java.lang.Object#clone()
     * @since   JDK1.0
     */
    public interface Cloneable {
    }
    

    我們會發現,這個類沒有任何的方法,怎麼來實現它,不要慌。先接着走。

    具體原型類 也就是我們具體要克隆 的對象。比如我們重複的要創建100個學生Student 對象,那麼具體的學生對象就是具體原型類

    public class Student implements Cloneable {
    
        private int id;
    
        private String name;
    
        private int sex;
    }
    

    訪問類 我就不必多說了

    淺克隆和深克隆

    原型模式其實也分淺克隆和深克隆。如何理解這兩個概念呢?

    淺克隆

    protected native Object clone() throws CloneNotSupportedException;
    

    淺克隆,只需要具體原型類 實現Cloneable 接口,並且重寫父類Object類的clone() 方法,即可實現對象的淺克隆。

    Student student1 = new Student(1, "李四");
    Student student2 = student1.clone();
    
    System.out.println(student1);
    System.out.println(student2);
    
    System.out.println(student1 == student2);
    ---------------------
    學號:1,姓名:李四
    學號:1,姓名:李四
    false
    
    • 通過執行clone() 方法即可創建一個相同的,具有同樣屬性的對象。
    • 並且是新的對象,內存地址有所不同。

    我們來看看,對於引用類型的變量,淺克隆是否可以進行克隆;

    Teacher teacher = new Teacher(1, "張老師");
    
    Student student1 = new Student(1, "李四", teacher);
    Student student2 = student1.clone();
    
    System.out.println(student1);
    System.out.println(student2);
    
    System.out.println(student1 == student2);
    ------------
    學號:1,姓名:李四,老師=Teacher@1b6d3586
    學號:1,姓名:李四,老師=Teacher@1b6d3586
    false
    

    我們發現,引用類型並沒有被克隆,也就是說:

    特點

    • 淺克隆對於基本類型,可以進行完全的克隆,並且克隆的對象是一個新的對象
    • 但是對象裏面的引用,是無法被克隆的。

    深克隆(序列化)

    何謂序列化?

    我們創建的都是保存在內存裏面的,只要被虛擬機GC進行回收,那麼這個對象的任何屬性都是消失,我們能不能找一個方法,將內存中這種對象的屬性以及對象的狀態通過某種東西保存下來,比如保存到數據庫,下次從數據庫將這個對象還原到內存裏面。 這就是序列化。

    • 序列化 內存對象->序列字符
    • 反序列化 序列字符->內存對象

    請參考: https://baike.baidu.com/item/序列化/2890184

    JAVA 序列化

     * @see java.io.Externalizable
     * @since   JDK1.1
     */
    public interface Serializable {
    }
    

    JAVA 提供了一個空接口,其實這個接口和上面的Cloneable 一樣,都是一個空接口,其實這個空接口就是作為一種標識 你的對象實現了這個接口,JAVA 認為你的這個就可以被序列化 ,就是這麼簡單。

    Teacher teacher = new Teacher(1, "張老師");
    
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    ObjectOutputStream stream = new ObjectOutputStream(outputStream);
    
    stream.writeObject(teacher);
    System.out.println(Arrays.toString(outputStream.toByteArray()));
    ----------
    [-84, -19, 0, 5, 115, 114, 0, 7, 84, 101, 97,。。。。。。
    

    通過將對象序列化、其實也就是將內存中的對象轉化為二進制 字節數組

    反序列化

    Teacher teacher = new Teacher(1, "張老師");
    System.out.println(teacher);
    
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    ObjectOutputStream stream = new ObjectOutputStream(outputStream);
    
    stream.writeObject(teacher);
    System.out.println(Arrays.toString(outputStream.toByteArray()));
    
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(outputStream.toByteArray());
    ObjectInputStream inputStream = new ObjectInputStream(byteArrayInputStream);
    
    Teacher teacher1 = (Teacher) inputStream.readObject();
    System.out.println(teacher1);
    ---------------
    id=1,name=張老師
    [-84, -19, 0, 5, 115, xxxxx,-127, -27, -72, -120]
    id=1,name=張老師
    

    通過序列化和反序列化,即可對象的深克隆

    小結

    這一節,在講述 原型模式的同時,將原有實現原型模式的clone() 淺克隆,延伸到深克隆這一概念。其實JAVA 的原型模式,實現起來較為簡單。但還是要按需要實現,Object 類提供的 clone 淺克隆 是沒辦法克隆對象的引用類型的。需要克隆引用類型,還是需要序列化 深克隆

    參考

    http://c.biancheng.net/view/1343.html
    https://www.liaoxuefeng.com/wiki/1252599548343744/1298366845681698

    代碼示例

    https://gitee.com/mrc1999/Dev-Examples

    歡迎關注

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

    【其他文章推薦】

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

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

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

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

    ※超省錢租車方案

    FB行銷專家,教你從零開始的技巧

  • Java多線程之內存模型

    Java多線程之內存模型

    目錄

    • 多線程需要解決的問題
      • 線程之間的通信
      • 線程之間的同步
    • Java內存模型
      • 內存間的交互操作
      • 指令屏障
      • happens-before規則
    • 指令重排序
      • 從源程序到字節指令的重排序
      • as-if-serial語義
      • 程序順序規則
    • 順序一致性模型
      • 順序一致性模型特性
      • 順序一致性模型特性
      • 當程序未正確同步會發生什麼
    • 參考資料

    多線程需要解決的問題

    在多線程編程中,線程之間如何通信和同步是一個必須解決的問題:

    線程之間的通信:

    線程之間有兩種通信的方式:消息傳遞和共享內存

    • 共享內存:線程之間共享程序的公共狀態,通過讀——寫修改公共狀態進行隱式通信。如上面代碼中的numLock可以被理解為公共狀態
    • 消息傳遞:線程之間沒有公共狀態,必須通過發送消息來進行显示通信
      在java中,線程是通過共享內存來完成線程之間的通信

    線程之間的同步:

    同步指程序中永固空值不同線程間的操作發生的相對順序的機制

    • 共享內存:同步是显示進行的,程序員需要指定某個方法或者某段代碼需要在線程之間互斥執行。如上面代碼中的Lock加鎖和解鎖之間的代碼塊,或者被synchronized包圍的代碼塊
    • 消息傳遞:同步是隱式執行的,因為消息的發送必然發生在消息的接收之前,例如使用Objetc#notify(),喚醒的線程接收信號一定在發送喚醒信號的發送之後。

    Java內存模型

    在java中,所有的實例域,靜態域、數組都被存儲在堆空間當中,堆內存在線程之間共享。

    所有的局部變量,方法定義參數和異常處理器參數不會被線程共享,在每個線程棧中獨享,他們不會存在可見性和線程安全問題。

    從Java線程模型(JMM)的角度來看,線程之間的共享變量存儲在主內存當中,每個線程擁有一個私有的本地內存(工作內存)本地內存存儲了該線程讀——寫共享的變量的副本。
    JMM只是一個抽象的概念,在現實中並不存在,其中所有的存儲區域都在堆內存當中。JMM的模型圖如下圖所示:

    而java線程對於共享變量的操作都是對於本地內存(工作內存)中的副本的操作,並沒有對共享內存中原始的共享變量進行操作;

    以線程1和線程2為例,假設線程1修改了共享變量,那麼他們之間需要通信就需要兩個步驟:

    1. 線程1本地內存中修改過的共享變量的副本同步到共享內存中去
    2. 線程2從共享內存中讀取被線程1更新過的共享變量
      這樣才能完成線程1的修改對線程2的可見。

    內存間的交互操作

    為了完成這一線程之間的通信,JMM為內存間的交互操作定義了8個原子操作,如下錶:

    操作 作用域 說明
    lock(鎖定) 共享內存中的變量 把一個變量標識為一條線程獨佔的狀態
    unlock(解鎖) 共享內存中的變量 把一個處於鎖定的變量釋放出來,釋放后其他線程可以進行訪問
    read(讀取) 共享內存中的變量 把一個變量的值從共享內存傳輸到線程的工作內存。供隨後的load操作使用
    load(載入) 工作內存 把read操作從共享內存中得到的變量值放入工作內存的變量副本當中
    use(使用) 工作內存 把工作內存中的一個變量值傳遞給執行引擎
    assign(賦值) 工作內存 把一個從執行引擎接受到的值賦值給工作內存的變量
    store(存儲) 作用於工作內存 把一個工作內存中的變量傳遞給共享內存,供後續的write使用
    write(寫入) 共享內存中的變量 把store操作從工作內存中得到的變量的值放入主內存

    JMM規定JVM四線時必須保證上述8個原子操作是不可再分割的,同時必須滿足以下的規則:

    1. 不允許readloadstorewrite操作之一單獨出現,即不允許只從共享內存讀取但工作內存不接受,或者工作捏村發起回寫但是共享內存不接收
    2. 不允許一個線程捨棄assign操作,即當一個線程修改了變量后必須寫回工作內存和共享內存
    3. 不允許一個線程將未修改的變量值寫回共享內存
    4. 變量只能從共享內存中誕生,不允許線程直接使用未初始化的變量
    5. 一個變量同一時刻只能由一個線程對其執行lock操作,但是一個變量可以被同一個線程重複執行多次lock,但是需要相同次數的unlock
    6. 如果對一個變量執行lock操作,那麼會清空工作內存中此變量的值,在執行引擎使用這個變量之前需要重新執行load和assign
    7. 不允許unlock一個沒有被鎖定的變量,也不允許unlock一個其他線程lock的變量
    8. 對一個變量unlock之前必須把此變量同步回主存當中。

    longdouble的特殊操作
    在一些32位的處理器上,如果要求對64位的longdouble的寫具有原子性,會有較大的開銷,為了照固這種情況,
    java語言規範鼓勵但不要求虛擬機對64位的longdouble型變量的寫操作具有原子性,當JVM在這種處理器上運行時,
    可能會把64位的long和double拆分成兩次32位的寫

    指令屏障

    為了保證內存的可見性,JMM的編譯器會禁止特定類型的編譯器重新排序;對於處理器的重新排序,
    JMM會要求編譯器在生成指令序列時插入特定類型的的內存屏障指令,通過內存屏障指令巾紙特定類型的處理器重新排序

    JMM規定了四種內存屏障,具體如下:

    屏障類型 指令示例 說明
    LoadLoad Barriers Load1;LoadLoad;Load2 確保Load1的數據先於Load2以及所有後續裝在指令的裝載
    StoreStore Barries Store1;StoreStore;Store2 確保Store1數據對於其他處理器可見(刷新到內存)先於Store2及後續存儲指令的存儲
    LoadStore Barriers Load1;LoadStore;Store2 確保Load1的裝載先於Store2及後續所有的存儲指令
    StoreLoad Barrier Store1;StoreLoad;Load2 確保Store1的存儲指令先於Load1以及後續所所有的加載指令

    StoreLoad是一個“萬能”的內存屏障,他同時具有其他三個內存屏障的效果,現代的處理器大都支持該屏障(其他的內存屏障不一定支持),
    但是執行這個內存屏障的開銷很昂貴,因為需要將處理器緩衝區所有的數據刷回內存中。

    happens-before規則

    在JSR-133種內存模型種引入了happens-before規則來闡述操作之間的內存可見性。在JVM種如果一個操作的結果過需要對另一個操作可見,
    那麼兩個操作之間必然要存在happens-bsfore關係:

    • 程序順序規則:一個線程中的個每個操作,happens-before於該線程的後續所有操作
    • 監視器鎖規則:對於一個鎖的解鎖,happens-before於隨後對於這個鎖的加鎖
    • volatitle變量規則:對於一個volatile的寫,happens-before於認意後續對這個volatile域的讀
    • 線程啟動原則:對線程的start()操作先行發生於線程內的任何操作
    • 線程終止原則:線程中的所有操作先行發生於檢測到線程終止,可以通過Thread.join()、Thread.isAlive()的返回值檢測線程是否已經終止
    • 線程終端原則:對線程的interrupt()的調用先行發生於線程的代碼中檢測到中斷事件的發生,可以通過Thread.interrupted()方法檢測是否發生中斷
    • 對象終結原則:一個對象的初始化完成(構造方法執行結束)先行發生於它的finalize()方法的開始。
    • 傳遞性:如果A happens-before B B happends-beforeC,那麼A happends-before C

    指令重排序

    從源程序到字節指令的重排序

    眾所周知,JVM執行的是字節碼,Java源代碼需要先編譯成字節碼程序才能在Java虛擬機中運行,但是考慮下面的程序;

    int a = 1;
    int b = 1;
    

    在這段代碼中,ab沒有任何的相互依賴關係,因此完全可以先對b初始化賦值,再對a變量初始化賦值;

    事實上,為了提高性能,編譯器和處理器通常會對指令做重新排序。重排序分為3種:

    1. 編譯器優化的重排序。編譯器在不改變單線程的程序語義的前提下,可以安排字語句的執行順序。編譯器的對象是語句,不是字節碼,
      但是反應的結果就是編譯后的字節碼和寫的語句順序不一致。
    2. 執行級并行的重排序。現代處理器採用了并行技術,來將多條指令重疊執行。如果不存在數據依賴性,處理器可以改變語句對應機器指令的執行順序。
    3. 內存系統的重排序,由於處理器使用了緩存和讀/寫緩衝區,這使得加載和存儲操作看上去可能是在亂序執行。

    數據依賴性:如果兩個操作訪問同一個變量,且兩個操作有一個是寫操作,則這兩個操作存在數據依賴性,改變這兩個操作的執行順序,就會改變執行結果。

    儘管指令重排序會提高代碼的執行效率,但是卻為多線程編程帶來了問題,多線程操作共享變量需要一定程度上遵循代碼的編寫順序,
    也需要將修改的共享數據存儲到共享內存中,不按照代碼順序執行可能會導致多線程程序出現內存可見性的問題,那又如何實現呢?

    as-if-serial語義

    as-if-serial語義:不論程序怎樣進行重排序,(單線程)程序的執行結果不能被改變。編譯器、runtime和處理器都必須支持as-if-serial語義。

    程序順序規則

    假設存在以下happens-before程序規則:

        1) A happens-before B
        2) B happens-before C
        3) A happens-before C
    

    儘管這裏存在A happens-before B這一關係,但是JMM並不要求A一定要在B之前執行,僅僅要求A的執行結果對B可見。
    即JMM僅要求前一個操作的結果對於后一個操作可見,並且前一個操作按照順序排在後一個操作之前。
    但是若前一個操作放在後一個操作之後執行並不影響執行結果,則JMM認為這並不違法,JMM允許這種重排序。

    順序一致性模型

    在一個線程中寫一個變量,在另一個線程中同時讀取這個變量,讀和寫沒有通過排序來同步來排序,就會引發數據競爭。

    數據競爭的核心原因是程序未正確同步。如果一個多線程程序是正確同步的,這個程序將是一個沒有數據競爭的程序。

    順序一致性模型只是一個參考模型。

    順序一致性模型特性

    • 一個線程中所有的操作必須按照程序的順序來執行。
    • 不管線程是否同步,所有的線程都只能看到一個單一的執行順序。

    在順序一致性模型中每個曹祖都必須原子執行且立刻對所有線程可見。

    當程序未正確同步會發生什麼

    當線程未正確同步時,JMM只提供最小的安全性,當讀取到一個值時,這個值要麼是之前寫入的值,要麼是默認值。
    JMM保證線程的操作不會無中生有。為了保證這一特點,JMM在分配對象時,首先會對內存空間清0,然後才在上面分配對象。

    未同步的程序在JMM種執行時,整體上是無序的,執行結果也無法預知。位同步程序子兩個模型中執行特點有如下幾個差異:

    • 順序一致性模型保證單線程內的操作會按照程序的順序執行,而JMM不保證單線程內的操作會按照程序的順序執行
    • 順序一致性模型保證所有線程只能看到一致的操作執行順序,而JMM不保證所有線程能看到一致的操作執行順序
    • JMM不保證對64位的longdouble型變量具有寫操作的原子性,而順序一致性模型保證對所有的內存的讀/寫操作都具有原子性

    參考資料

    java併發編程的藝術-方騰飛,魏鵬,程曉明著

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

    【其他文章推薦】

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

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

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

    ※超省錢租車方案

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

    網頁設計最專業,超強功能平台可客製化

    【其他文章推薦】

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

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

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

    ※超省錢租車方案

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

    網頁設計最專業,超強功能平台可客製化

  • 【Mongodb】 可複製集搭建

    【Mongodb】 可複製集搭建

    可複製集 replica set

    概念圖

    可複製集需要至少3個以上的mongodb節點,其中有一個主節點promary,其餘的為副本節點secondary

    可複製集有三個角色:

    • 主要成員(Primary):主要接收所有寫操作。就是主節點。
    • 副本成員(Secondary):從主節點通過複製操作以維護相同的數據集,即備份數據,不可寫操作,但可以讀操作(但需要配置)。是默認的一種從節點類型。
    • 仲裁者(Arbiter):不保留任何數據的副本,只具有投票選舉作用。當然也可以將仲裁服務器維護為副本集的一部分,即副本成員同時也可以是仲裁者。也是一種從節點類型。

    關於仲裁者:
    如果主節點+副本節點是偶數推薦添加仲裁者,如果主節點+ 副本節點是奇數可以不添加仲裁者。仲裁者將永遠是仲裁者,而主要人員可能會退出並成為次要人員,而次要人員可能成為選舉期間的主要人員。

    為什麼要用可複製集?它有什麼重要性?

    1. 避免數據丟失,保障數據安全,提高系統安全性;
      (最少3節點,最大50節點)
    2. 自動化災備機制,主節點宕機后通過選舉產生新主機;提高系統健壯性;
      (7個選舉節點上限)
    3. 讀寫分離,負載均衡,提高系統性能;

    搭建

    準備三個mongodb節點

    正準備三個mongodb節點,我們先搭建一個主節點,2個副本節點的模式
    修改配置mongo.conf

    • 第一個
    systemLog:
      #MongoDB發送所有日誌輸出的目標指定為文件 
      destination: file
      #mongod或mongos應向其發送所有診斷日誌記錄信息的日誌文件的路徑 
      path: "/home/amber/mongodb/mongodb-001/log/mongod.log" 
      #當mongos或mongod實例重新啟動時,mongos或mongod會將新條目附加到現有日誌文件的末尾。 
      logAppend: true
    storage: 
      #mongod實例存儲其數據的目錄。storage.dbPath設置僅適用於mongod。 
      dbPath: "/home/amber/mongodb/mongodb-001/data/db" 
      journal:
        #啟用或禁用持久性日誌以確保數據文件保持有效和可恢復。 
        enabled: true
    processManagement:
      #啟用在後台運行mongos或mongod進程的守護進程模式。 
      fork: true 
      #指定用於保存mongos或mongod進程的進程ID的文件位置,其中mongos或mongod將寫入其PID 
      pidFilePath: "/home/amber/mongodb/mongodb-001/log/mongod.pid" 
    net:
      #服務實例綁定所有IP,有副作用,副本集初始化的時候,節點名字會自動設置為本地域名,而不是ip 
      #bindIpAll: true 
      #服務實例綁定的IP 
      bindIp: 0.0.0.0
      #bindIp 
      #綁定的端口 
      port: 27017
    replication: 
      #副本集的名稱 
      replSetName: myrs
    
    • 第二個第三個配置
      把上述文件中的mongodb-001換成mongodb-002``mongodb-003
      端口分別換成27018 27019

    然後分別在mongodb-00X的根目錄下執行啟動命令

    ./bin/mongod -f ./conf/mongod.conf
    

    檢查進程

    ps -ef|grep mongod
    

    設置主節點

    進入27017的那個mongod的客戶端,並且執行

    rs.initiate({
          _id: "myrs", //  需要和replSetName的名稱一致
          version: 1,
          members: [{ _id: 0, host : "192.168.xx.xx:27017" }]});
    

    或者

    rs.initiate({}) 
    

    執行結果

    提示:
    1)“ok”的值為1,說明創建成功。
    2)命令行提示符發生變化,變成了一個從節點角色,此時默認不能讀寫。稍等片刻,回車,變成主節  點。
    

    配置副本節點

    再27017的mongod客戶端,也就是主節點上執行192.168.xx.xx:27018是副本節點的ip和端口

    rs.add("192.168.xx.xx:27018")
    rs.add("192.168.xx.xx:27019")
    

    使用

    rs.status()
    

    就可以看到members會有三個節點了

    測試

    再主節點插入一條數據

    use article;
    db.comment.insert({name: "amber"})
    

    再從節點查看,結果

    這是因為需要再從節點再次進行

    rs.slaveok() // 確認當前節點是副本節點
    db.comment.find(); // 查看當前數據
    

    可以看到已經有數據了,這樣一主二從的可複製成功了

    如果關閉主節點,在從節點執行rs.status();
    可以看到原來的主節點的health變成了0

    27018變成了新的主節點

    主節點的選舉原則

    MongoDB在副本集中,主節點選舉的觸發條件:
    1) 主節點故障
    2) 主節點網絡不可達(默認心跳信息為10秒)
    3) 人工干預(rs.stepDown(600))

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

    【其他文章推薦】

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

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

    ※回頭車貨運收費標準

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

    ※超省錢租車方案

    ※產品缺大量曝光嗎?你需要的是一流包裝設計!

  • 【Spring註解驅動開發】使用InitializingBean和DisposableBean來管理bean的生命周期,你真的了解嗎?

    寫在前面

    在《【Spring註解驅動開發】如何使用@Bean註解指定初始化和銷毀的方法?看這一篇就夠了!!》一文中,我們講述了如何使用@Bean註解來指定bean初始化和銷毀的方法。具體的用法就是在@Bean註解中使用init-method屬性和destroy-method屬性來指定初始化方法和銷毀方法。除此之外,Spring中是否還提供了其他的方式來對bean實例進行初始化和銷毀呢?

    項目工程源碼已經提交到GitHub:https://github.com/sunshinelyz/spring-annotation

    InitializingBean接口

    1.InitializingBean接口概述

    Spring中提供了一個InitializingBean接口,InitializingBean接口為bean提供了屬性初始化后的處理方法,它只包括afterPropertiesSet方法,凡是繼承該接口的類,在bean的屬性初始化后都會執行該方法。InitializingBean接口的源碼如下所示。

    package org.springframework.beans.factory;
    public interface InitializingBean {
    	void afterPropertiesSet() throws Exception;
    }
    

    根據InitializingBean接口中提供的afterPropertiesSet()方法的名字可以推斷出:afterPropertiesSet()方法是在屬性賦好值之後調用的。那到底是不是這樣呢?我們來分析下afterPropertiesSet()方法的調用時機。

    2.何時調用InitializingBean接口?

    我們定位到Spring中的org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory類下的invokeInitMethods()方法中,來查看Spring加載bean的方法。

    題外話:不要問我為什麼會是這個invokeInitMethods()方法,如果你和我一樣對Spring的源碼非常熟悉的話,你也會知道是這個invokeInitMethods()方法,哈哈哈哈!所以,小夥伴們不要只顧着使用Spring,還是要多看看Spring的源碼啊!Spring框架中使用了大量優秀的設計模型,其代碼的編寫規範和嚴謹程度也是業界開源框架中數一數二的,非常值得閱讀。

    我們來到AbstractAutowireCapableBeanFactory類下的invokeInitMethods()方法,如下所示。

    protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
        throws Throwable {
    	//判斷該bean是否實現了實現了InitializingBean接口,如果實現了InitializingBean接口,則調用bean的afterPropertiesSet方法
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        //調用afterPropertiesSet()方法
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                //調用afterPropertiesSet()方法
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }
    
        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
                //通過反射的方式調用init-method
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }
    

    分析上述代碼后,我們可以初步得出如下信息:

    • Spring為bean提供了兩種初始化bean的方式,實現InitializingBean接口,實現afterPropertiesSet方法,或者在配置文件和@Bean註解中通過init-method指定,兩種方式可以同時使用。
    • 實現InitializingBean接口是直接調用afterPropertiesSet()方法,比通過反射調用init-method指定的方法效率相對來說要高點。但是init-method方式消除了對Spring的依賴。
    • 如果調用afterPropertiesSet方法時出錯,則不調用init-method指定的方法。

    也就是說Spring為bean提供了兩種初始化的方式,第一種實現InitializingBean接口,實現afterPropertiesSet方法,第二種配置文件或@Bean註解中通過init-method指定,兩種方式可以同時使用,同時使用先調用afterPropertiesSet方法,后執行init-method指定的方法。

    DisposableBean接口

    1.DisposableBean接口概述

    實現org.springframework.beans.factory.DisposableBean接口的bean在銷毀前,Spring將會調用DisposableBean接口的destroy()方法。我們先來看下DisposableBean接口的源碼,如下所示。

    package org.springframework.beans.factory;
    public interface DisposableBean {
    	void destroy() throws Exception;
    }
    

    可以看到,在DisposableBean接口中只定義了一個destroy()方法。

    在Bean生命周期結束前調用destory()方法做一些收尾工作,亦可以使用destory-method。前者與Spring耦合高,使用類型強轉.方法名(),效率高。後者耦合低,使用反射,效率相對低

    2.DisposableBean接口注意事項

    多例bean的生命周期不歸Spring容器來管理,這裏的DisposableBean中的方法是由Spring容器來調用的,所以如果一個多例實現了DisposableBean是沒有啥意義的,因為相應的方法根本不會被調用,當然在XML配置文件中指定了destroy方法,也是沒有意義的。所以,在多實例bean情況下,Spring不會自動調用bean的銷毀方法。

    單實例bean案例

    創建一個Animal的類實現InitializingBean和DisposableBean接口,代碼如下:

    package io.mykit.spring.plugins.register.bean;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.stereotype.Component;
    /**
     * @author binghe
     * @version 1.0.0
     * @description 測試InitializingBean接口和DisposableBean接口
     */
    public class Animal implements InitializingBean, DisposableBean {
        public Animal(){
            System.out.println("執行了Animal類的無參數構造方法");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("執行了Animal類的初始化方法。。。。。");
    
        }
        @Override
        public void destroy() throws Exception {
            System.out.println("執行了Animal類的銷毀方法。。。。。");
    
        }
    }
    

    接下來,我們新建一個AnimalConfig類,並將Animal通過@Bean註解的方式註冊到Spring容器中,如下所示。

    package io.mykit.spring.plugins.register.config;
    
    import io.mykit.spring.plugins.register.bean.Animal;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    /**
     * @author binghe
     * @version 1.0.0
     * @description AnimalConfig
     */
    @Configuration
    @ComponentScan("io.mykit.spring.plugins.register.bean")
    public class AnimalConfig {
        @Bean
        public Animal animal(){
            return new Animal();
        }
    }
    

    接下來,我們在BeanLifeCircleTest類中新增testBeanLifeCircle02()方法來進行測試,如下所示。

    @Test
    public void testBeanLifeCircle02(){
        //創建IOC容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
        System.out.println("IOC容器創建完成...");
        //關閉IOC容器
        context.close();
    }
    

    運行BeanLifeCircleTest類中的testBeanLifeCircle02()方法,輸出的結果信息如下所示。

    執行了Animal類的無參數構造方法
    執行了Animal類的初始化方法。。。。。
    IOC容器創建完成...
    執行了Animal類的銷毀方法。。。。。
    

    從輸出的結果信息可以看出:單實例bean下,IOC容器創建完成后,會自動調用bean的初始化方法;而在容器銷毀前,會自動調用bean的銷毀方法。

    多實例bean案例

    多實例bean的案例代碼基本與單實例bean的案例代碼相同,只不過在AnimalConfig類中,我們在animal()方法上添加了@Scope(“prototype”)註解,如下所示。

    package io.mykit.spring.plugins.register.config;
    import io.mykit.spring.plugins.register.bean.Animal;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Scope;
    /**
     * @author binghe
     * @version 1.0.0
     * @description AnimalConfig
     */
    @Configuration
    @ComponentScan("io.mykit.spring.plugins.register.bean")
    public class AnimalConfig {
        @Bean
        @Scope("prototype")
        public Animal animal(){
            return new Animal();
        }
    }
    

    接下來,我們在BeanLifeCircleTest類中新增testBeanLifeCircle03()方法來進行測試,如下所示。

    @Test
    public void testBeanLifeCircle03(){
        //創建IOC容器
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AnimalConfig.class);
        System.out.println("IOC容器創建完成...");
        System.out.println("-------");
        //調用時創建對象
        Object bean = ctx.getBean("animal");
        System.out.println("-------");
        //調用時創建對象
        Object bean1 = ctx.getBean("animal");
        System.out.println("-------");
        //關閉IOC容器
        ctx.close();
    }
    

    運行BeanLifeCircleTest類中的testBeanLifeCircle03()方法,輸出的結果信息如下所示。

    IOC容器創建完成...
    -------
    執行了Animal類的無參數構造方法
    執行了Animal類的初始化方法。。。。。
    -------
    執行了Animal類的無參數構造方法
    執行了Animal類的初始化方法。。。。。
    -------
    

    從輸出的結果信息中可以看出:在多實例bean情況下,Spring不會自動調用bean的銷毀方法。

    好了,咱們今天就聊到這兒吧!別忘了給個在看和轉發,讓更多的人看到,一起學習一起進步!!

    項目工程源碼已經提交到GitHub:https://github.com/sunshinelyz/spring-annotation

    寫在最後

    如果覺得文章對你有點幫助,請微信搜索並關注「 冰河技術 」微信公眾號,跟冰河學習Spring註解驅動開發。公眾號回復“spring註解”關鍵字,領取Spring註解驅動開發核心知識圖,讓Spring註解驅動開發不再迷茫。

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

    【其他文章推薦】

    ※超省錢租車方案

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

    ※回頭車貨運收費標準

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

    FB行銷專家,教你從零開始的技巧

  • 三文搞懂學會Docker容器技術(上)

    三文搞懂學會Docker容器技術(上)

    1,Docker簡介

      1.1 Docker是什麼?

    Docker官網: https://www.docker.com/

    Docker 是一個開源的應用容器引擎,基於 Go 語言 並遵從Apache2.0協議開源。
    Docker 可以讓開發者打包他們的應用以及依賴包到一個輕量級、可移植的容器中,然後發布到任何流行的 Linux 機器上,也可以實現虛擬化。
    容器是完全使用沙箱機制,相互之間不會有任何接口(類似 iPhone 的 app),更重要的是容器性能開銷極低。
    Docker 從 17.03 版本之後分為 CE(Community Edition: 社區版) 和 EE(Enterprise Edition: 企業版),我們用社區版就可以了。

      1.2 Docker架構原理?

     

    Docker三要素,鏡像,容器,倉庫

    1.鏡像

    Docker 鏡像(Image)就是一個只讀的模板,它可以是一個可運行軟件(tomcat,mysql),也可以是一個系統(centos)。鏡像可以用來創建 Docker 容器,一個鏡像可以創建很多容器。

    2.容器

    Docker 利用容器(Container)獨立運行的一個或一組應用。容器是用鏡像創建的運行實例。它可以被啟動、開始、停止、刪除。每個容器都是相互隔離的、保證安全的平台。可以把容器看做是一個簡易版的 Linux 環境(包括root用戶權限、進程空間、用戶空間和網絡空間等)和運行在其中的應用程序。容器的定義和鏡像幾乎一模一樣,也是一堆層的統一視角,唯一區別在於容器的最上面那一層是可讀可寫的。

    3.倉庫

    倉庫(Repository)是集中存放鏡像文件的場所,類似GitHub存放項目代碼一樣,只不過Docker Hub是由來存鏡像(image)的。倉庫(Repository)和倉庫註冊服務器(Registry)是有區別的。倉庫註冊服務器上往往存放着多個倉庫,每個倉庫中又包含了多個鏡像,每個鏡像有不同的標籤(tag,類似版本號)。

    倉庫分為公開倉庫(Public)和私有倉庫(Private)兩種形式。

    最大的公開倉庫是 Docker Hub(https://hub.docker.com/),存放了數量龐大的鏡像供用戶下載。國內的公開倉庫包括阿里雲 、網易雲 等。

     

    容器與鏡像的關係類似於面向對象編程中的對象與類。

    Docker 面向對象
    容器 對象
    鏡像

      1.3 Docker有什麼用?

        1,簡化環境搭建,提高開發生命周期效率;

        2,大大簡化運維工作量;

        3,微服務利器;

      1.4 Docker容器與虛擬機區別?

    Docker是一種輕量級的虛擬化技術,比傳統的虛擬機性能更好。

    下圖是虛擬機的體繫結構:

     

    • server – 表示真實電腦。
    • Host OS – 真實電腦的操作系統,例如:Windows,Linux
    • Hypervisor – 虛擬機平台,模擬硬件,如VMWare,VirtualBox
    • Guest OS – 虛擬機平台上安裝的操作系統,例如CentOS Linux
    • App – 虛擬機操作系統上的應用,例如nginx

     

    下圖是Docker的體繫結構:

    • server – 表示真實電腦。
    • Host OS – 真實電腦的操作系統,例如:Windows,Linux
    • Docker Engine – 新一代虛擬化技術,不需要包含單獨的操作系統。
    • App – 所有的應用程序現在都作為Docker容器運行。

     

    這種體繫結構的明顯優勢是,不需要為虛擬機操作系統提供硬件模擬。所有應用程序都作為Docker容器工作,性能更好。

      Docker容器 虛擬機(VM)
    操作系統 與宿主機共享OS 宿主機OS上運行宿主機OS
    存儲大小 鏡像小,便於存儲與傳輸 鏡像龐大(vmdk等)
    運行性能 幾乎無額外性能損失 操作系統額外的cpu、內存消耗
    移植性 輕便、靈活、適用於Linux 笨重、與虛擬化技術耦合度高
    硬件親和性  面向軟件開發者 面向硬件運維者

     

    Docker優點:輕量級,速度快,運行應用隔離,方便維護…

    2,Docker安裝

      2.1 Docker版本介紹

    Docker從1.13版本之後採用時間線的方式作為版本號,分為社區版CE和企業版EE。

    社區版是免費提供給個人開發者和小型團體使用的,企業版會提供額外的收費服務,比如經過官方測試認證過的基礎設施、容器、插件等。

    社區版按照stable和edge兩種方式發布,每個季度更新stable版本,如17.06,17.09;每個月份更新edge版本,如17.09,17.10。

    我們平時用社區版就足夠了。所以我們安裝社區版;

      2.2 Docker安裝官方文檔

    我們主要參考:https://docs.docker.com/install/linux/docker-ce/centos/  來安裝;

      2.3 工具準備

    前置課程:Centos課程  http://www.java1234.com/javaxuexiluxiantu.html

    打包下載: http://pan.baidu.com/s/1i55jJAt

    虛擬機 VMware

    centos7安裝下虛擬機VM上;

    連接工具 才用 FinalShell  官方地址:http://www.hostbuf.com/

      2.4 Docker安裝步驟

    我們切換到root用戶

    1、Docker 要求 CentOS 系統的內核版本高於 3.10 ,查看本頁面的前提條件來驗證你的CentOS 版本是否支持 Docker 。

    通過 uname -r 命令查看你當前的內核版本

     $ uname -r

    2、使用 root 權限登錄 Centos。確保 yum 包更新到最新。

    $ yum update

    3、卸載舊版本(如果安裝過舊版本的話)

    $ yum remove docker  docker-common docker-selinux docker-engine

    4、安裝需要的軟件包, yum-util 提供yum-config-manager功能,另外兩個是devicemapper驅動依賴的

    $ yum install -y yum-utils device-mapper-persistent-data lvm2

    5、設置yum源

    $ yum-config-manager –add-repo https://download.docker.com/linux/centos/docker-ce.repo

    6,安裝最新版本的Docker

    $ yum install docker-ce docker-ce-cli containerd.io

    7,啟動Docker並設置開機啟動

    $ systemctl start docker

    $ systemctl enable docker

    8,驗證Docker

    $ docker version

     

    說明安裝OK;

    9,Docker HelloWorld測試;

    $ docker run hello-world

     

    因為本地沒有這個鏡像,所以從遠程官方倉庫去拉取,下載;

    然後我們再執行一次;

     

    OK了

      2.5 Docker配置阿里雲鏡像倉庫

    Docker默認遠程倉庫是 https://hub.docker.com/

    比如我們下載一個大點的東西,龜速

     

    由於是國外主機,類似Maven倉庫,慢得一腿,經常延遲,破損;

    所以我們一般都是配置國內鏡像,比如阿里雲,網易雲等;推薦阿里雲,穩定點;

    配置步驟如下:

    1,登錄進入阿里雲鏡像服務中心,獲取鏡像地址

    進入阿里雲容器鏡像服務地址:點這裏快速進入

    使用你的淘寶賬號密碼登錄

     

    這裏我們獲取鏡像地址;

    2,在/etc/docker目錄下找到在daemon.json文件(沒有就新建),將下面內容寫入

    {

     “registry-mirrors”: [“https://xxxxxxx.mirror.aliyuncs.com”]

    }

    3,重啟daemon

    systemctl daemon-reload

    4,重啟docker服務

    systemctl restart docker

    5,測試

    由於速度太快,截圖都難;

     

    3,HelloWorld運行原理

    運行  docker run hello-world

    本地倉庫未能找到該鏡像,然後去遠程倉庫尋找以及下載該鏡像;

    然後我們再執行該命令:

    出來了 Hellowold。我們具體來分析下 執行原理和過程;

    從左到右 client客戶端,Docker運行主機,遠程倉庫;

    docker build ,pull,run分別是 構建,拉取,運行命令,後面再細講;

    中間Docker主機里有 Docker daemon主運行線程,以及Containers容器,容器里可以運行很多實例,(實例是從右側Images鏡像實例化出來的)Images是存儲再本地的鏡像文件,比如 Redis,Tomat這些鏡像文件;

    右側是Registry鏡像倉庫,默認遠程鏡像倉庫 https://hub.docker.com/  不過是國外主機,下載很慢,不穩定,所以我們後面要配置成阿里雲倉庫鏡像地址,穩定快捷;

    執行 docker run hello-world的過程看如下圖例:

     

     

     

    4,Docker基本命令

       4.1 啟動Docker

               systemctl start docker

      4.2 停止Docker

             systemctl stop docker

      4.3 重啟Docker

           systemctl restart docker

      4.4 開機啟動Docker

         systemctl enable docker

      4.5 查看Docker概要信息

       docker info

      4.6 查看Docker幫助文檔

       docker –help

      4.7 查看Docker版本信息

         docker version

    5,Docker鏡像

      5.1 docker images 列出本機所有鏡像

     

    REPOSITORY 鏡像的倉庫源
    TAG 鏡像的標籤(版本)同一個倉庫有多個TAG的鏡像,多個版本;我們用REPOSITORY:TAG來定義不同的鏡像;
    IMAGE ID 鏡像ID,鏡像的唯一標識
    CREATE 鏡像創建時間
    SIZE 鏡像大小

    OPTIONS 可選參數:

    -a 显示所有鏡像(包括中間層)
    q 只显示鏡像ID
    -qa 可以組合
    –digests 显示鏡像的摘要信息
    –no-trunc 显示完整的鏡像信息 

     

      5.2 docker search 搜索鏡像

    和 https://hub.docker.com/ 這裏的搜索效果一樣;

    OPTIONS可選參數:

    –no-trunc 显示完整的鏡像描述
    -s 列出收藏數不小於指定值的鏡像
    –automated 只列出Docker Hub自動構建類型的鏡像

     

     

     

      5.3 docker pull 下載鏡像

    docker pull 鏡像名稱:[TAG]

    注意:不加TAG,默認下載最新版本latest

      5.4 docker rmi 刪除鏡像

    1,刪除單個:docker rmi 鏡像名稱:[TAG]

    如果不寫TAG,默認刪除最新版本latest

    有鏡像生成的容器再運行時候,會報錯,刪除失敗;

    我們需要加 -f 強制刪除

    2,刪除多個:docker rmi -f 鏡像名稱1:[TAG] 鏡像名稱2:[TAG]

    中間空格隔開

    3,刪除全部:docker rmi -f $(docker images -qa)

     

     

    ——————————————————————————————————————————

    作者: java1234_小鋒

    出處:https://www.cnblogs.com/java688/p/13132444.html

    版權:本站使用「CC BY 4.0」創作共享協議,轉載請在文章明顯位置註明作者及出處。

    ——————————————————————————————————————————

     

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

    【其他文章推薦】

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

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

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

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

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

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

  • Windows7/10實現ICMP(ping命令)

    Windows7/10實現ICMP(ping命令)

      如果覺得本文如果幫到你或者你想轉載都可以,只需要標註出處即可。謝謝

     利用ICMP數據包、C語言實現Ping命令程序,能實現基本的Ping操作,發送ICMP回顯請求報文,用於測試—個主機到只一個主機之間的連通情況。通過本程序的訓練,熟悉ICMP報文結構,對ICMP有更深的理解,掌握Ping程序的設計方法,掌握網絡編程的方法和技巧,從而編寫出功能更強大的程序。有關traceroute如果有時間我會也寫一篇來進行講解.W

      windows和Linux實現ping的底層思想一樣的,代碼有細微的差別。如文文件不一樣,參數定義不一樣等。所以我們要實現ping功能的時候我們需要注意是在Windows上實現還是Linux上實現。

      如果你不想看關於ping命令實現的原理,則可以直接通過以下目錄跳轉到‘8.實現Ping功能’即可.

      本文目錄

      1.ICMP簡介

      2.ICMP工作原理

      3.ICMP報文格式

      4.ICMPv4類型

        4.1響應請求/應答(ping)

        4.2.目標不可到達、源抑制和超時報文

      5.ICMP應用

      6.ICMP攻擊與防禦方法

      7.IP報文頭和ICMP的聯繫

      8.實現Ping功能

        8.1.ping實現步驟

        8.2.結果及心得

        8.3.完整代碼

    1.ICMP簡介

      ICMP(Internet Control Message Protocol)Internet控制報文協議。它是TCP/IP協議簇的一個子協議,用於在IP主機、路由器之間傳遞控制消息。控制消息是指網絡通不通、主機是否可達、路由是否可用等網絡本身的消息。這些控制消息雖然並不傳輸用戶數據,但是對於用戶數據的傳遞起着重要的作用。

     ICMP協議是一種面向無連接的協議,用於傳輸出錯報告控制信息。它是一個非常重要的協議,它對於網絡安全具有極其重要的意義。

      ICMP報文通常是由IP層本身、上層的傳輸協議(TCP或UDP)甚至某些情況下用戶應用除法執行的。

      ICMP報文是在IP數據報內被封裝傳輸的。

      ICMP分為兩大類:有關IP數據報傳遞的ICMP報文(稱為差錯報文(error message)),以及有關信息採集和配置的ICMP報文(稱為查詢(query)或者信息類報文(informational message))。

      注:ICMP並不為IP網絡提供可靠性。相反,它表明了某些類別的故障和配置信息。

    2.ICMP工作原理

      ICMP提供一致易懂的出錯報告信息。發送的出錯報文返回到發送原數據的設備,因為只有發送設備才是出錯報文的邏輯接受者。發送設備隨後可根據ICMP報文確定發生錯誤的類型,並確定如何才能更好地重發失敗的數據包。但是ICMP唯一的功能是報告問題而不是糾正錯誤,糾正錯誤的任務由發送方完成。

      我們在網絡中經常會使用到ICMP協議,比如我們經常使用的用於檢查網絡通不通的Ping命令(Linux和Windows中均有),這個“Ping”的過程實際上就是ICMP協議工作的過程。還有其他的網絡命令如跟蹤路由的Tracert命令也是基於ICMP協議的。

    3.ICMP報文格式

      ICMP報文包含在IP數據報中,屬於IP的一個用戶,IP頭部就在ICMP報文的前面,所以一個ICMP報文包括IP頭部、ICMP頭部和ICMP報文,IP頭部的Protocol值為1就說明這是一個ICMP報文,ICMP頭部中的類型(Type)域用於說明ICMP報文的作用及格式,此外還有一個代碼(Code)域用於詳細說明某種ICMP報文的類型,所有數據都在ICMP頭部後面。

      ICMPICMP報文格式具體由[RFC777][RFC792]規範。792是1981年9月更新,而777是1981年4月更新的。目前最新的ICMP報文格式RFC是2007年4月更新的[RFC488].

     

    4.ICMPv4類型

      已經定義的ICMP消息類型大約有10多種,每種ICMP數據類型都被封裝在一個IP數據包中。主要的ICMP消息類型包括以下幾種。

      對於ICMPv4,信息類報文包括回顯請求和回顯應答(分別為類型8和0),以及路由器通告和路由器請求(分別為類型9和10,統一被稱為路由器發現)。最常見的差錯報文類型包括目的不可達(類型3)、重定向(類型5)、超時(類型11)和參數問題(類型12).下圖為一些類型.更多的信息建議去RFC官方查看,Type和Code在IPv4和IPc6不盡相同,所以其中的差異需要我們自行去查看,本圖為IPv4版本的,IPv6需要我們自己RFC查找。

     

    1).響應請求/應答(ping)(ICMPv4類型為0/8,ICMPv6類型129/18)

      我們日常使用最多的ping,就是響應請求(Type=8)和應答(Type=0),一台主機向一個節點發送一個Type=8的ICMP報文,如果途中沒有異常(例如被路由器丟棄、目標不回應ICMP或傳輸失敗),則目標返回Type=0的ICMP報文,說明這台主機存在,更詳細的tracert通過計算ICMP報文通過的節點來確定主機與目標之間的網絡距離。更多的信息我們可以通過RFC文檔了解

     

    2).目標不可到達(ICMPv4類型3,ICMPv6類型1)、源抑制和超時報文(ICMPv4類型11,ICMPv6類型4)

      這三種報文的格式是一樣的,目標不可到達報文(Type=3)在路由器或主機不能傳遞數據報時使用,例如我們要連接對方一個不存在的系統端口(端口號小於1024)時,將返回Type=3、Code=3的ICMP報文,它要告訴我們:“嘿,別連接了,我不在家的!”,常見的不可到達類型還有網絡不可到達(Code=0)、主機不可到達(Code=1)、協議不可到達(Code=2)等。源抑制則充當一個控制流量的角色,它通知主機減少數據報流量,由於ICMP沒有恢復傳輸的報文,所以只要停止該報文,主機就會逐漸恢復傳輸速率。最後,無連接方式網絡的問題就是數據報會丟失,或者長時間在網絡遊盪而找不到目標,或者擁塞導致主機在規定時間內無法重組數據報分段,這時就要觸發ICMP超時報文的產生。超時報文的代碼域有兩種取值:Code=0表示傳輸超時,Code=1表示重組分段超時。更多的信息我們可以通過RFC文檔了解

     

    5.ICMP應用

    1).ping 命令使用 ICMP 回送請求和應答報文在網絡可達性測試中使用的分組網間探測命令 ping 能產生 ICMP 回送請求和應答報文。目的主機收到 ICMP 回送請求報文後立刻回送應答報文,若源主機能收到 ICMP 回送應答報文,則說明到達該主機的網絡正常。

    2).路由分析診斷程序 tracert 使用了 ICMP時間超過報文tracert 命令主要用來显示數據包到達目的主機所經過的路徑。通過執行一個 tracert 到對方主機的命令,返回數據包到達目的主機所經歷的路徑詳細信息,並显示每個路徑所消耗的時間。

     

    6.ICMP攻擊

      涉及ICMP的攻擊主要分為3類:泛洪(flood)、炸彈(bomb)、信息泄露(information disclosure).針對TCP的ICMP攻擊已經被專門記錄在RFC文檔中[RFC5927]

    1).泛洪(flood)

      泛洪將會生成大量流量,導致針對一台或者多台計算機的有效Dos攻擊

    2).炸彈(bomb)

      炸彈類型有時也稱為核彈(nuke)類型,指的是發送經過特殊構造的報文,能夠導致IP或ICMP的處理崩潰或者終止。

    3).信息泄露(information disclosure)

      信息泄露攻擊本身不會造成危害,但是能夠幫助其他攻擊方法避免浪費時間或者被發現了。

    7.IP報文頭和ICMP的聯繫

      ICMP報文是封裝在IP數據報的數據部分中進行傳輸的.

     

      ICMP依靠IP來完成它的任務,它是IP的主要部分。它與傳輸協議(如TCP和UDP)顯著不同:它一般不用於在兩點間傳輸數據。它通常不由網絡程序直接使用,除了 ping 和 traceroute 這兩個特別的例子。 IPv4中的ICMP被稱作ICMPv4,IPv6中的ICMP則被稱作ICMPv6。

     

      總的來說,ICMP是封裝在IP數據報中進行傳輸的.具體更多的聯繫我們通過以下改文章進行詳解,從Wireshark抓包然後分析數據包進行兩者的區別和聯繫.

      參考文檔:https://www.cnblogs.com/CSAH/p/13170860.html

    8.實現Ping功能

      首先我們注意,本文只是實現ping的最簡單的功能即響應請求/應答(ping),故只能夠ping IP地址,不能夠ping 域名,因為域名到IP地址我們需要經過DNS解析,本文不實現該功能.關於DNS轉換到IP地址的詳情,有時間有機會我會補上的.

      本程序使用的環境是win10+vc++6.0,如果沒有安裝VC++6.0的或者在Win10安裝了無法使用的請查看’Win10安裝vc6.0教程‘。

      ping功能實現參考了TCP/IP詳解 卷1 和 卷2。

    1).實現步驟

      首先,我們需要先定義初始化一些全局變量,接着我們對需要用到的數據類型結構進行聲明定義,我們包含的數據類型結構有IP報頭結構、ICMP數據類型結構、結果集類型結構等;對需要使用到的函數進行頭文件的導入,主要的區別在於使用的是Windows系統還是Linux系統,導入的頭文件也不盡相同。準備工作全都完成了,然後我們就可以定義main函數進行試驗的驗證測試。

      其次,我們需要對每一步的遇到的問題需要寫一份說明報告書,以防下次再進行實驗時遇到同樣的問題時,我們無需再去查找大量資料。

      最後,我們對整個實驗的總結,對每一步。每一個函數進行詳講.做好註釋.

      Ping()函數是本程序的核心部分,它基本是調用其他模塊的函數來實現最終功能,其主要布驟包括:定義及初始化各個全局變量、打開socket動態庫、設置接收和發送超時值、域名地址解析、分配內存、創建及初始化ICMP報文、發送ICMP請求報文、接收ICMP 應答報文以及解讀應答報文和輸出Ping結果。

     

      注意:創建套接字的時候參數的以及在創建套接字之前必須首先使用WSAStartup函數。

    (1)輸入時不能輸入目標主機名,不然ping結果為TIMEOUT

     

    (2)該模塊並非只有處理還包括判斷及輸出判斷結果的含義

    (3)程序沒運行一次就只能輸出四行結果(前提是輸入的地址有效),欲再次PING其他地址接着輸入下一個ip地址即可

     

    2).代碼實現

        如果要想實現Windows下ping功能的實現,我們只需要從(1)到(8)複製到任意一個新創建filename.cpp文件中即可執行.或者最簡單的方法就是到本文中最低直接複製’完整代碼’到任意一個新創建filename.cpp文件中即可執行

    (1).頭文件、全局變量

    #include<stdio.h>
    #include<Winsock2.h>
    #include<ws2tcpip.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<string.h>
    #pragma comment(lib , "Ws2_32.lib")
    
    #define ICMP_ECHO_REQUEST 8 //定義回顯請求類型
    #define DEF_ICMP_DATA_SIZE 20 //定義發送數據長度
    #define DEF_ICMP_PACK_SIZE 32 //定義數據包長度
    #define MAX_ICMP_PACKET_SIZE 1024 //定義最大數據包長度
    #define DEF_ICMP_TIMEOUT 3000  //定義超時為3秒
    #define ICMP_TIMEOUT 11 //ICMP超時報文
    #define ICMP_ECHO_REPLY 0 //定義回顯應答類型
    

      

    (2).IP報頭據類型

    /*
     *IP報頭結構
     */
    typedef struct
    {
        byte h_len_ver ; //IP版本號
        byte tos ; // 服務類型
        unsigned short total_len ; //IP包總長度
        unsigned short ident ; // 標識
        unsigned short frag_and_flags ; //標誌位
        byte ttl ; //生存時間
        byte proto ; //協議
        unsigned short cksum ; //IP首部校驗和
        unsigned long sourceIP ; //源IP地址
        unsigned long destIP ; //目的IP地址
    } IP_HEADER ;
    

      

    (3).ICMP數據類型

    /*
     *定義ICMP數據類型
     */
    typedef struct _ICMP_HEADER
    {
        byte type ; //類型-----8
        byte code ; //代碼-----8
        unsigned short cksum ; //校驗和------16
        unsigned short id ; //標識符-------16
        unsigned short seq ; //序列號------16
        unsigned int choose ; //選項-------32
    } ICMP_HEADER ;
    

      

    (4).ping返回結果集數據類型

    typedef struct
    {
        int usSeqNo ; //記錄序列號
        DWORD dwRoundTripTime ; //記錄當前時間
        byte ttl ; //生存時間
        in_addr dwIPaddr ; //源IP地址
    } DECODE_RESULT ;
    

      

    (5).網際校驗和

    /*
     *產生網際校驗和
     */
    unsigned short GenerateChecksum(unsigned short *pBuf , int iSize)
    {
        unsigned long cksum = 0 ; //開始時將網際校驗和初始化為0
        while(iSize > 1)
        {
            cksum += *pBuf++ ; //將待校驗的數據每16位逐位相加保存在cksum中
            iSize -= sizeof(unsigned short) ; //每16位加完則將帶校驗數據量減去16
        }
        //如果待校驗的數據為奇數,則循環完之後需將最後一個字節的內容與之前結果相加
        if(iSize)
        {
            cksum += *(unsigned char*)pBuf ;
        }
            //之前的結果產生了進位,需要把進位也加入最後的結果中
        cksum = (cksum >> 16) + (cksum & 0xffff) ;
        cksum += (cksum >> 16) ;
        return (unsigned short)(~ cksum) ;
    }
    

      

    (6).ping信息解析

    /*
     *對ping應答信息進行解析
     */
    boolean DecodeIcmpResponse_Ping(char *pBuf , int iPacketSize , DECODE_RESULT *stDecodeResult)
    {
        IP_HEADER *pIpHrd = (IP_HEADER*)pBuf ;
        int iIphedLen = 20 ;
        if(iPacketSize < (int)(iIphedLen + sizeof(ICMP_HEADER)))
        {
            printf("size error! \n") ;
            return 0 ;
        }
        //指針指向ICMP報文的首地址
        ICMP_HEADER *pIcmpHrd = (ICMP_HEADER*)(pBuf + iIphedLen) ;
        unsigned short usID , usSeqNo ;
        //獲得的數據包的type字段為ICMP_ECHO_REPLY,即收到一個回顯應答ICMP報文
        if(pIcmpHrd->type == ICMP_ECHO_REPLY)
        {
            usID = pIcmpHrd->id ;
            //接收到的是網絡字節順序的seq字段信息 , 需轉化為主機字節順序
            usSeqNo = ntohs(pIcmpHrd->seq) ;
        }
        if(usID != GetCurrentProcessId() || usSeqNo != stDecodeResult->usSeqNo)
        {
            printf("usID error!\n") ;
            return 0 ;
        }
        //記錄對方主機的IP地址以及計算往返的時延RTT
        if(pIcmpHrd->type == ICMP_ECHO_REPLY)
        {
            stDecodeResult->dwIPaddr.s_addr = pIpHrd->sourceIP ;
            stDecodeResult->ttl = pIpHrd->ttl ;
            stDecodeResult->dwRoundTripTime = GetTickCount() - stDecodeResult->dwRoundTripTime ;
            return 1 ;
        }
        return 0 ;
    }
    

      

    (7).ping功能實現集成

    void Ping(char *IP)
    {
       unsigned long ulDestIP = inet_addr(IP) ; //將IP地址轉化為長整形
       if(ulDestIP == INADDR_NONE)
       {
           //轉化不成功時按域名解析
           HOSTENT *pHostent = gethostbyname(IP) ;
           if(pHostent)
           {
               ulDestIP = (*(IN_ADDR*)pHostent->h_addr).s_addr ; //將HOSTENT轉化為長整形
           }
           else
           {
               printf("TIMEOUT\n") ;
               return ;
           }
       }
       //填充目的Socket地址
       SOCKADDR_IN destSockAddr ; //定義目的地址
       ZeroMemory(&destSockAddr , sizeof(SOCKADDR_IN)) ; //將目的地址清空
       destSockAddr.sin_family = AF_INET ;
       destSockAddr.sin_addr.s_addr = ulDestIP ;
       destSockAddr.sin_port = htons(0);
        //初始化WinSock
        WORD wVersionRequested = MAKEWORD(2,2);
        WSADATA wsaData;
        if(WSAStartup(wVersionRequested,&wsaData) != 0)
        {
            printf("初始化WinSock失敗!\n") ;
            return ;
        }
       //使用ICMP協議創建Raw Socket
       SOCKET sockRaw = WSASocket(AF_INET , SOCK_RAW , IPPROTO_ICMP , NULL , 0 , WSA_FLAG_OVERLAPPED) ;
       if(sockRaw == INVALID_SOCKET)
       {
           printf("創建Socket失敗 !\n") ;
           return ;
       }
       //設置端口屬性
       int iTimeout = DEF_ICMP_TIMEOUT ;
       if(setsockopt(sockRaw , SOL_SOCKET , SO_RCVTIMEO , (char*)&iTimeout , sizeof(iTimeout)) == SOCKET_ERROR)
       {
             printf("設置參數失敗!\n") ;
             return ;
       }
       if(setsockopt(sockRaw , SOL_SOCKET , SO_SNDTIMEO , (char*)&iTimeout , sizeof(iTimeout)) == SOCKET_ERROR)
       {
             printf("設置參數失敗!\n") ;
             return ;
       }
       //定義發送的數據段
       char IcmpSendBuf[DEF_ICMP_PACK_SIZE] ;
       //填充ICMP數據包個各字段
       ICMP_HEADER *pIcmpHeader  = (ICMP_HEADER*)IcmpSendBuf;
       pIcmpHeader->type = ICMP_ECHO_REQUEST ;
       pIcmpHeader->code = 0 ;
       pIcmpHeader->id = (unsigned short)GetCurrentProcessId() ;
       memset(IcmpSendBuf + sizeof(ICMP_HEADER) , 'E' , DEF_ICMP_DATA_SIZE) ;
       //循環發送四個請求回顯icmp數據包
       int usSeqNo = 0 ;
       DECODE_RESULT stDecodeResult ;
       while(usSeqNo <= 3)
       {
         pIcmpHeader->seq = htons(usSeqNo) ;
         pIcmpHeader->cksum = 0 ;
         pIcmpHeader->cksum = GenerateChecksum((unsigned short*)IcmpSendBuf , DEF_ICMP_PACK_SIZE) ; //生成校驗位
         //記錄序列號和當前時間
         stDecodeResult.usSeqNo = usSeqNo ;
         stDecodeResult.dwRoundTripTime = GetTickCount() ;
         //發送ICMP的EchoRequest數據包
         if(sendto(sockRaw , IcmpSendBuf , DEF_ICMP_PACK_SIZE , 0 , (SOCKADDR*)&destSockAddr , sizeof(destSockAddr)) == SOCKET_ERROR)
         {
            //如果目的主機不可達則直接退出
            if(WSAGetLastError() == WSAEHOSTUNREACH)
            {
                printf("目的主機不可達!\n") ;
                exit(0) ;
            }
         }
         SOCKADDR_IN from ;
         int iFromLen = sizeof(from) ;
         int iReadLen ;
         //定義接收的數據包
         char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE] ;
         while(1)
         {
             iReadLen = recvfrom(sockRaw , IcmpRecvBuf , MAX_ICMP_PACKET_SIZE , 0 , (SOCKADDR*)&from , &iFromLen) ;
             if(iReadLen != SOCKET_ERROR)
             {
                 if(DecodeIcmpResponse_Ping(IcmpRecvBuf , sizeof(IcmpRecvBuf) , &stDecodeResult))
                 {
                    printf("來自 %s 的回復: 字節 = %d 時間 = %dms TTL = %d\n" , inet_ntoa(stDecodeResult.dwIPaddr) ,
                             iReadLen - 20,stDecodeResult.dwRoundTripTime ,stDecodeResult.ttl) ;
                 }
                 break ;
             }
             else if(WSAGetLastError() == WSAETIMEDOUT)
             {
                 printf("time out !  *****\n") ;
                 break ;
             }
             else
             {
                 printf("發生未知錯誤!\n") ;
                 break ;
             }
         }
         usSeqNo++ ;
       }
       //輸出屏幕信息
       printf("Ping complete...\n") ;
       closesocket(sockRaw) ;
       WSACleanup() ;
    }
    

      

    ①.inet_addr:可以轉化字符串,主要用來將一個十進制的數轉化為二進制的數,用途多於ipv4的IP轉化。

    ②.if(IpAddress == INADDR_NONE):INADDR_NONE 是個宏定義,代表IpAddress是否為無效的IP地址。

    ③.ckaddr_in:定義目的地址信息;

     

    ④.ZeroMemory:用0來填充一塊內存區域.ZeroMemory只能用於windows平台.

     

    ⑤.WSASocket:創建一個原始套接字。使用時需要包含winsock2.h 頭文件和鏈接ws2_32.lib庫。

    ⑥.SOCKET socket==INVALID_SOCKET:如果socket為無效套接字,則結果為true;

    ⑦.DEF_ICMP_TIMEOUT:報文超時時間.

    ⑧.setsockopt:選項影響套接口的操作,諸如加急數據是否在普通數據流中接收,廣播數據是否可以從套接口發送等等。

    ⑨.while(usSeqNo <= 3){}:該部分就是實驗要求我們一次測試的進行發包4次

    (8).Test測試

    int main(int argc , char* argv[])
    {
       char  com[10] , IP[20] ;
       while(1){
       printf("command>>") ;
       scanf("%s %s" , com , IP) ;
       if(strcmp(com , "ping") == 0)
       {
           Ping(IP) ;
       }
       else
       {
           printf("輸入錯誤 ! \n") ;
       }
       }
       return 0 ;
    }
    

      

    2).結果及心得

    (1).查看本機IP

     

    (2).ping網關IP

     

    (3).ping本機IP

     

    (4).ping局域網內IP

     

    (5).問題與解決方案

    ①.問題:telnet是23端口,ssh是22端口,那麼ping是什麼端口?

    答:ping基於ICMP,是在網絡層運行的。而端口號為傳輸層的內容。所以在ICMP中根本就不需要關注端口號這樣的信息。

    ②.Win7、win10 在VC6.0運行時WSASocket 返回錯誤 10013

      

    3).完整代碼

     

    #include<stdio.h>
    #include<Winsock2.h>
    #include<ws2tcpip.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<string.h>
    #pragma comment(lib , "Ws2_32.lib")
    
    
    #define ICMP_ECHO_REQUEST 8 //定義回顯請求類型
    #define DEF_ICMP_DATA_SIZE 20 //定義發送數據長度
    #define DEF_ICMP_PACK_SIZE 32 //定義數據包長度
    #define MAX_ICMP_PACKET_SIZE 1024 //定義最大數據包長度
    #define DEF_ICMP_TIMEOUT 3000  //定義超時為3秒
    #define ICMP_TIMEOUT 11 //ICMP超時報文
    #define ICMP_ECHO_REPLY 0 //定義回顯應答類型
    /*
     *IP報頭結構
     */
    typedef struct
    {
        byte h_len_ver ; //IP版本號
        byte tos ; // 服務類型
        unsigned short total_len ; //IP包總長度
        unsigned short ident ; // 標識
        unsigned short frag_and_flags ; //標誌位
        byte ttl ; //生存時間
        byte proto ; //協議
        unsigned short cksum ; //IP首部校驗和
        unsigned long sourceIP ; //源IP地址
        unsigned long destIP ; //目的IP地址
    } IP_HEADER ;
    /*
     *定義ICMP數據類型
     */
    typedef struct _ICMP_HEADER
    {
        byte type ; //類型-----8
        byte code ; //代碼-----8
        unsigned short cksum ; //校驗和------16
        unsigned short id ; //標識符-------16
        unsigned short seq ; //序列號------16
        unsigned int choose ; //選項-------32
    } ICMP_HEADER ;
    
    
    typedef struct
    {
        int usSeqNo ; //記錄序列號
        DWORD dwRoundTripTime ; //記錄當前時間
        byte ttl ; //生存時間
        in_addr dwIPaddr ; //源IP地址
    } DECODE_RESULT ;
    
    /*
     *產生網際校驗和
     */
    unsigned short GenerateChecksum(unsigned short *pBuf , int iSize)
    {
        unsigned long cksum = 0 ; //開始時將網際校驗和初始化為0
        while(iSize > 1)
        {
            cksum += *pBuf++ ; //將待校驗的數據每16位逐位相加保存在cksum中
            iSize -= sizeof(unsigned short) ; //每16位加完則將帶校驗數據量減去16
        }
        //如果待校驗的數據為奇數,則循環完之後需將最後一個字節的內容與之前結果相加
        if(iSize)
        {
            cksum += *(unsigned char*)pBuf ;
        }
            //之前的結果產生了進位,需要把進位也加入最後的結果中
        cksum = (cksum >> 16) + (cksum & 0xffff) ;
        cksum += (cksum >> 16) ;
        return (unsigned short)(~ cksum) ;
    }
    
    /*
     *對ping應答信息進行解析
     */
    boolean DecodeIcmpResponse_Ping(char *pBuf , int iPacketSize , DECODE_RESULT *stDecodeResult)
    {
        IP_HEADER *pIpHrd = (IP_HEADER*)pBuf ;
        int iIphedLen = 20 ;
        if(iPacketSize < (int)(iIphedLen + sizeof(ICMP_HEADER)))
        {
            printf("size error! \n") ;
            return 0 ;
        }
        //指針指向ICMP報文的首地址
        ICMP_HEADER *pIcmpHrd = (ICMP_HEADER*)(pBuf + iIphedLen) ;
        unsigned short usID , usSeqNo ;
        //獲得的數據包的type字段為ICMP_ECHO_REPLY,即收到一個回顯應答ICMP報文
        if(pIcmpHrd->type == ICMP_ECHO_REPLY)
        {
            usID = pIcmpHrd->id ;
            //接收到的是網絡字節順序的seq字段信息 , 需轉化為主機字節順序
            usSeqNo = ntohs(pIcmpHrd->seq) ;
        }
        if(usID != GetCurrentProcessId() || usSeqNo != stDecodeResult->usSeqNo)
        {
            printf("usID error!\n") ;
            return 0 ;
        }
        //記錄對方主機的IP地址以及計算往返的時延RTT
        if(pIcmpHrd->type == ICMP_ECHO_REPLY)
        {
            stDecodeResult->dwIPaddr.s_addr = pIpHrd->sourceIP ;
            stDecodeResult->ttl = pIpHrd->ttl ;
            stDecodeResult->dwRoundTripTime = GetTickCount() - stDecodeResult->dwRoundTripTime ;
            return 1 ;
        }
        return 0 ;
    }
    
    void Ping(char *IP)
    {
       unsigned long ulDestIP = inet_addr(IP) ; //將IP地址轉化為長整形
       if(ulDestIP == INADDR_NONE)
       {
           //轉化不成功時按域名解析
           HOSTENT *pHostent = gethostbyname(IP) ;
           if(pHostent)
           {
               ulDestIP = (*(IN_ADDR*)pHostent->h_addr).s_addr ; //將HOSTENT轉化為長整形
           }
           else
           {
               printf("TIMEOUT\n") ;
               return ;
           }
       }
       //填充目的Socket地址
       SOCKADDR_IN destSockAddr ; //定義目的地址
       ZeroMemory(&destSockAddr , sizeof(SOCKADDR_IN)) ; //將目的地址清空
       destSockAddr.sin_family = AF_INET ;
       destSockAddr.sin_addr.s_addr = ulDestIP ;
       destSockAddr.sin_port = htons(0);
        //初始化WinSock
        WORD wVersionRequested = MAKEWORD(2,2);
        WSADATA wsaData;
        if(WSAStartup(wVersionRequested,&wsaData) != 0)
        {
            printf("初始化WinSock失敗!\n") ;
            return ;
        }
       //使用ICMP協議創建Raw Socket
       SOCKET sockRaw = WSASocket(AF_INET , SOCK_RAW , IPPROTO_ICMP , NULL , 0 , WSA_FLAG_OVERLAPPED) ;
       if(sockRaw == INVALID_SOCKET)
       {
           printf("創建Socket失敗 !\n") ;
           return ;
       }
       //設置端口屬性
       int iTimeout = DEF_ICMP_TIMEOUT ;
       if(setsockopt(sockRaw , SOL_SOCKET , SO_RCVTIMEO , (char*)&iTimeout , sizeof(iTimeout)) == SOCKET_ERROR)
       {
             printf("設置參數失敗!\n") ;
             return ;
       }
       if(setsockopt(sockRaw , SOL_SOCKET , SO_SNDTIMEO , (char*)&iTimeout , sizeof(iTimeout)) == SOCKET_ERROR)
       {
             printf("設置參數失敗!\n") ;
             return ;
       }
       //定義發送的數據段
       char IcmpSendBuf[DEF_ICMP_PACK_SIZE] ;
       //填充ICMP數據包個各字段
       ICMP_HEADER *pIcmpHeader  = (ICMP_HEADER*)IcmpSendBuf;
       pIcmpHeader->type = ICMP_ECHO_REQUEST ;
       pIcmpHeader->code = 0 ;
       pIcmpHeader->id = (unsigned short)GetCurrentProcessId() ;
       memset(IcmpSendBuf + sizeof(ICMP_HEADER) , 'E' , DEF_ICMP_DATA_SIZE) ;
       //循環發送四個請求回顯icmp數據包
       int usSeqNo = 0 ;
       DECODE_RESULT stDecodeResult ;
    
       while(usSeqNo <= 3)
       {
         pIcmpHeader->seq = htons(usSeqNo) ;
         pIcmpHeader->cksum = 0 ;
         pIcmpHeader->cksum = GenerateChecksum((unsigned short*)IcmpSendBuf , DEF_ICMP_PACK_SIZE) ; //生成校驗位
         //記錄序列號和當前時間
         stDecodeResult.usSeqNo = usSeqNo ;
         stDecodeResult.dwRoundTripTime = GetTickCount() ;
         //發送ICMP的EchoRequest數據包
         if(sendto(sockRaw , IcmpSendBuf , DEF_ICMP_PACK_SIZE , 0 , (SOCKADDR*)&destSockAddr , sizeof(destSockAddr)) == SOCKET_ERROR)
         {
            //如果目的主機不可達則直接退出
            if(WSAGetLastError() == WSAEHOSTUNREACH)
            {
                printf("目的主機不可達!\n") ;
                exit(0) ;
            }
         }
         SOCKADDR_IN from ;
         int iFromLen = sizeof(from) ;
         int iReadLen ;
         //定義接收的數據包
         char IcmpRecvBuf[MAX_ICMP_PACKET_SIZE] ;
         while(1)
         {
             iReadLen = recvfrom(sockRaw , IcmpRecvBuf , MAX_ICMP_PACKET_SIZE , 0 , (SOCKADDR*)&from , &iFromLen) ;
             if(iReadLen != SOCKET_ERROR)
             {
                 if(DecodeIcmpResponse_Ping(IcmpRecvBuf , sizeof(IcmpRecvBuf) , &stDecodeResult))
                 {
                    printf("來自 %s 的回復: 字節 = %d 時間 = %dms TTL = %d\n" , inet_ntoa(stDecodeResult.dwIPaddr) ,
                             iReadLen - 20,stDecodeResult.dwRoundTripTime ,stDecodeResult.ttl) ;
                 }
                 break ;
             }
             else if(WSAGetLastError() == WSAETIMEDOUT)
             {
                 printf("time out !  *****\n") ;
                 break ;
             }
             else
             {
                 printf("發生未知錯誤!\n") ;
                 break ;
             }
         }
         usSeqNo++ ;
       }
       //輸出屏幕信息
       printf("Ping complete...\n") ;
       closesocket(sockRaw) ;
       WSACleanup() ;
    }
    int main()
    {
       char  com[10] , IP[20] ;
       while(1){
       printf("command>>") ;
       scanf("%s %s" , com , IP) ;
       if(strcmp(com , "ping") == 0)
       {
           Ping(IP) ;
       }
       else
       {
           printf("輸入錯誤 ! \n") ;
       }
       }
       return 0 ;
    }
    

      

    參考文檔:https://zhidao.baidu.com/question/1946506262344388308.html

    https://docs.microsoft.com/zh-cn/windows/win32/api/winsock2/nf-winsock2-wsasocketa?redirectedfrom=MSDN

    https://zhidao.baidu.com/question/541753723.html

    TCP/IP網絡原理技術[清華大學出版社 周明天,汪文勇]

    互聯網控制消息協議[維基百科]

    TCP/IP詳解 卷1:協議

    TCP/IP詳解 卷2:實現

     

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

    【其他文章推薦】

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

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

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

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

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

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