各種鎖、volatile、synchronized、單例模式

来源:https://www.cnblogs.com/hexiayuliang666/archive/2022/04/17/16156232.html
-Advertisement-
Play Games

各種鎖 可重入鎖、公平鎖\非公平鎖、獨占鎖\共用鎖、讀寫鎖 鎖狀態 重量級鎖、輕量級鎖、偏量鎖、鎖膨脹、鎖粗化、鎖自旋\自定義自旋 volatile輕量級鎖，鎖變數，可見性 synchronized使用方式，不同使用方式的底層實現，非公平鎖，鎖升級原理，鎖優化，降級 單例模式與synchronize... ...


1、鎖

（1）各種鎖

==可重入鎖（遞歸鎖）：廣義上的可重入鎖，並非單指ReentrantLock。指的是同一線程外層函數獲得鎖後，內層遞歸函數仍然有獲得該鎖的代碼，但不鎖影響。

==公平鎖：加鎖前檢查是否有排隊等候的線程，優先排隊等待的線程，按排隊順序來。

==不公平鎖：加鎖時，不考慮排隊等候的線程，直接獲取鎖，獲取不到自動到隊尾等候，效率比公平鎖高，因為公平鎖維護了一個隊列。可插隊。

==讀寫鎖：ReadWriteLock\ReentrantReadWriteLock，在讀的地方使用讀鎖，在寫的地方使用寫鎖，多個讀鎖不互斥，讀鎖和寫鎖互斥。

==共用鎖和獨占鎖

         獨占鎖，每次只能有一個線程持有鎖，避免了讀/讀衝突。某個只讀線程獲取鎖，其它讀線程只能等待。如ReentrantLock獨占方式實現的互斥鎖。

         共用鎖，允許多個線程同時獲取鎖，併發訪問資源。如ReadWriteLock允許讀讀，AQS隊列等待線程鎖的獲取也是共用鎖。

（2）鎖的四個狀態：無鎖，重量級鎖，輕量級鎖，偏量鎖

重量級鎖：同一時間，有多個線程同時競爭鎖

      依賴操作系統的Mutex Lock來實現，會進行用戶態和內核態的轉換，和進程的上下文切換，使用系統的互斥量來實現鎖，效率低（synchronized效率低的原因）

輕量級鎖：存在兩個線程一前一後執行同步代碼塊時，不存在同時競爭鎖

      適應的場合是線程交替執行同步塊的情況和沒有多線程競爭的情況，如果存在同一時間訪問同一鎖的情況，會到導致鎖膨脹為重量級鎖。多次依賴CAS原子指令來獲取輕量級鎖和釋放鎖。

偏量鎖：總是由同一線程多次訪問同一同步代碼塊時，此時是偏量鎖

     線程訪問加鎖代碼時，會在對象頭中存儲當前線程的ID，後續這個線程進入和退出這段加鎖代碼時，就不需要再次加鎖和釋放鎖。只需要在置換ThreadID時進行一次CAS原子指令，會節省性能消耗。只有一個線程執行同步塊時偏量鎖能提高性能。

 

2、volatile

（1）CPU緩存模型：解決CPU處理速度和記憶體處理速度不對等的問題

（2）記憶體：可以看作外存的高速緩存，是硬碟數據用於解決硬碟訪問速度過慢的問題

（3）JMM記憶體模型：解決緩存不一致性問題

抽象  線程和主記憶體之間的關係

==主存：共用記憶體，所有線程創建的實例對象都存放在主記憶體中

==本地記憶體：每個線程都有一個私有的本地記憶體來存儲共用變數的副本。 每個線程只能訪問自己的本地記憶體，無法訪問其它線程的本地記憶體。

==造成的問題，一個線程在主存中修改一個變數的值，另一個線程還在繼續使用副本中的變數的值，會造成數據不一致性問題。解決方法：volatile

（4）併發編程的三個特性：

==1、原子性：一次或多次操作，要麼都執行，要麼都不執行。

        synchronized可以保證代碼片段的原子性。volatile不能保證

==2、可見性：一個線程對共用變數進行修改，另外的線程能立即可見修改後的最新值。

       synchronized和volatile可以保證共用變數的可見性。

==3、有序性：代碼執行過程中的代碼執行順序，未必是編寫代碼時的順序，可能造成指令重排。

       volatile可以禁止指令重排。

（5）synchronized和volatile的區別

==1、synchronized和volatile是互補的存在，不是對立的存在

==2、volatile輕量級實現，性能比synchronized好

==3、volatile只能作用於變數，synchronized能作用於變數、方法、類

==4、volatile主要用於解決多線程間記憶體可見性問題，使對volatile變數的讀寫直接寫入主存，保證變數的可見性。

          synchronized主要用於解決執行控制問題，能夠對修飾的代碼進行加鎖，阻止其它線程的訪問，保證線程間訪問資源的同步性。

==5、volatile不會造成線程阻塞，沒有鎖操作，synchronized會造成線程阻塞，會進行鎖操作。

==6、volatile、synchronized可以保證可見性，synchronized還可以保證原子性。

         synchronized保證可見性的原理：創建一個記憶體屏障，記憶體屏障指令保證所有CPU操作結果都會直接刷到主存中，從而保證操作的記憶體可見性，同時，記憶體屏障也可以禁止指令重排，從而保證有序性。

         volatile保證可見性原理：會創建一個記憶體屏障，使得記憶體屏障的指令不能重新排序，保證有序性。同時，本地線程中的volatile變數的值會立即寫入到主存中，並使其它線程共用的volatile變數無效化，其它線程必須重新從主存中讀取其變數值。

 

3、synchronized

(1)synchronized :解決多線程間訪問的資源的同步性，可以保證被修飾的方法或代碼塊在任意時刻只有一個線程執行。

(2)synchronized:重量級的鎖

(3)使用方式：（3種）

==1、修飾普通方法：作用於當前對象實例，加鎖，鎖的是當前實例對象

synchronized void method() {
    //業務代碼
}

==2、修飾靜態方法：作用於當前類，加鎖，鎖的是當前的class類

      進入同步代碼前要獲得當前class類的鎖，synchronized加到static靜態方法和synchronized(.class)代碼塊上，都是給class類上鎖。

synchronized static void method() {
    //業務代碼
}

==3、修飾代碼塊：指定加鎖對象，對指定的對象|類加鎖

     進入同步代碼前要獲得給定對象|類的鎖

     synchronized(this|object)表示進入同步代碼塊前要獲得給定對象的鎖

     synchronized(類.class)表示進入同步代碼塊前要獲得當前class的鎖

synchronized(this) {
    //業務代碼
}

====儘量不要使用synchronized(String a)，因為字元串常量池有緩存功能

====一個線程A調用一個實例對象的非靜態synchronized方法，而線程B需要調用這個實例對象所屬類的靜態synchronized方法，是允許的，不會發生互斥現象，因為訪問靜態synchronized方法占用的鎖，鎖的是當前類，而非靜態synchronized方法占用的鎖，鎖的是當前的實例對象。

（4）synchronized的底層實現原理

=1、synchronized關鍵字底層原理屬於JVM層面

       javap 可以查看類的相關位元組碼信息

==【1】、synchronized同步代碼塊的實現

使用 monitorenter 和 monitorexit 指令

      monitor是基於C++實現的，有ObjectMonitor實現，每個對象都有內置一個ObjectMonitor對象

      wait/notify 也依賴於monitor對象，因此只有在同步代碼塊和方法種才能調用wait/notify方法，否則會拋出java.lang.IllegalMonitorStateException的異常

===== monitorenter指令： 指向同步代碼塊的開始位置

===== monitorexit指令：指向同步代碼塊的結束位置

1、當執行monitorenter指令時，線程會獲取對象監視器monitor的持有權

2、同時，會嘗試獲取對象的鎖，鎖計數器為0說明鎖可以被獲取，獲取後鎖計數器設為1

3、線程擁有對象鎖才能執行monitorexit指令釋放鎖，執行monitorexit指令後，鎖計數器設為0，表明鎖被釋放，其它線程可以嘗試獲取鎖

4、獲取對象鎖失敗，當前線程會一直阻塞等待，直到鎖被運行中的線程釋放

==【2】、synchronized修飾方法的實現

沒有使用monitorenter 和 monitorexit 指令

使用 ACC_SYNCHRONIZED標識

=====ACC_SYNCHRONIZED標識，指明瞭該方法是一個同步方法

JVM通過ACC_SYNCHRONIZED標識辨別一個方法是否為同步方法，從而執行相應的同步調用

=====如果是實例方法，JVM會通過該ACC_SYNCHRONIZED標識，嘗試獲取實例對象的鎖

=====如果是靜態方法，JVM會通過該ACC_SYNCHRONIZED標識，嘗試獲取當前類class的鎖

==【3】synchronized修飾同步代碼塊和方法本質：獲取對象監視器monitor

（5）構造方法可以使用synchronized關鍵字修飾嗎？

不能，因為構造方法本身就屬於線程安全的，不存在同步的構造方法一說，因為實例對象還沒實例，怎麼會有競爭呢？

（6）synchronized為什麼是非公平鎖？體現在哪裡呢？

==[1] 當持有鎖的線程釋放鎖時，該線程會執行以下重要操作：

        先將鎖的持有者owner屬性賦值為null;

        喚醒等待鏈表中的一個線程。

        在喚醒等待的線程期間（還沒喚醒），若有其它線程嘗試獲取鎖，可以馬上獲取到鎖。（不公平，可插隊）

==[2]當線程嘗試獲取鎖失敗，會進入阻塞，會將線程放入鏈表裡邊，但喚醒的順序不確定，先進入鏈表不代表會先被喚醒。（不公平，沒順序）

（7）synchronized鎖升級的原理

==[1]過程： 偏量鎖——>輕量級鎖——>重量級鎖

       一個線程第一次訪問同步代碼塊時，鎖對象的對象頭中有一個ThreadId欄位，第一次訪問時，ThreadId為空，jvm會讓其獲得偏量鎖，並將ThreadId設置為其線程id(依賴一次CAS原子指令)；

       當線程再次進入這個同步代碼塊時，會先判斷ThreadId是否與線程id一致，一致則可以直接使用此對象（不用再獲取鎖、釋放鎖）；不一致則進行鎖升級，偏量鎖升級為輕量級鎖，通過鎖自旋（依賴多次CAS原子指令），迴圈一定次數後來獲取鎖，獲取要使用的對象；

       輕量級鎖自旋一定次數後還沒有獲取到使用的對象，就會進行鎖升級，輕量級鎖升級為重量級鎖（依賴操作系統的Metux Lock），來獲取鎖和要獲取的對象；

       這些過程構成了synchronized鎖的升級。

==[2]目的：鎖升級是為了減低鎖帶來的性能消耗。

      Java6後優化synchronized的實現方式，使用了這種鎖升級的方式，減低了鎖帶來的性能消耗。

（8）JVM對 synchronized 的優化

==[1]新增了鎖的狀態：鎖消除、鎖粗化、自旋鎖

==[2]鎖膨脹（升級）：實際中到一定情況下會進行升級

=====膨脹（升級）方向：無鎖--->偏量鎖--->輕量級鎖--->重量級鎖

=====膨脹不可逆 膨脹的方向不能逆向

=====膨脹原理：有一個線程多次執行同一同步代碼塊時，此時，便是偏量鎖；當存在兩個線程一前一後執行同一同步代碼塊時，不存在同時競爭鎖的情況下，此時便是輕量級鎖；（期間，ThreadId存在不同，便會進行鎖升級，偏量級鎖升級為輕量級鎖）；當存在多個線程同時競爭鎖對象，同時要執行同一同步代碼塊時，便是重量級鎖。（期間，存在多線程競爭，輕量級鎖升級為重量級鎖）

==[3]鎖膨脹：優化更徹底，去除不可能存在競爭的鎖

     優化前：synchronized(object){}

     優化後：直接去掉該synchronized(){}

     原因：因為object鎖是私有變數，不存在競爭關係

==[4]鎖粗化：更極端的優化處理，通過擴大鎖的範圍，避免反覆加鎖和釋放鎖。

    優化前：for(){synchronized(xxx.class){}}

    優化後：synchronized(xxx.class){for(){}}

    原因：避免反覆加鎖解鎖，擴大鎖的範圍

==[5]自旋鎖：輕量級鎖切換線程時，線程執行迴圈一定次數等待鎖的釋放，不讓出CPU，缺點：一直沒獲取鎖，一直不釋放CPU，會帶來性能開銷

==[6]自適應自旋鎖：自旋鎖的優化，自旋次數不再固定，自旋次數由前一次在同一鎖上的自旋時間及鎖的擁有者的狀態來決定。

（9）synchronized鎖能降級嗎？（降為無鎖狀態）

可以！！！但要具體的觸發時機

==[1]觸發時機：在全局安全點（sagepoint），執行清理任務時會觸發嘗試降級鎖。

==[2]降級鎖的操作：1、恢復鎖對象的markword對象頭

                                  2、重置ObjectMonitor，將ObjectMonitor放入全局空閑列表，等待後續使用。

 

4、單例模式與volatile、synchronized

(1)餓漢式單例（使用前創建對象，反射可以破壞單例）

//餓漢式 單例
public class aHungry {
    // 在使用時就已經存在  可能會浪費空間
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    //構造器私有
    private aHungry(){}
    private final static aHungry hungry = new aHungry();// 直接載入對象
    public static aHungry getInstance(){
       return hungry;
    }
}

(2)懶漢式單例（使用時才進行對象創建）

//懶漢式單例
public class bLazyMan {
    private bLazyMan() {          System.out.println(Thread.currentThread().getName()+"==>  ok");
    }
    private  static bLazyMan bLazyMan;
    public static bLazyMan getInstance(){
       //沒加鎖 當要使用時才創建對象
           if (bLazyMan==null){
              bLazyMan = new bLazyMan();
          }
          return bLazyMan;
    }
public static void main(String[] args) {
//        bLazyMan.getInstance();  // 單線程下 單例
//        多線程併發下 懶漢式單例 會有問題  可能有一個或多個線程  因此可以加鎖  -->雙重檢測鎖模式懶漢式 DCL懶漢式
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                bLazyMan.getInstance();
            }).start();
        }
    }
}

(3)雙重檢驗鎖懶漢式單例 DCL懶漢式

//雙重檢驗鎖
public class CLockLazyMan {
    private CLockLazyMan() {          System.out.println(Thread.currentThread().getName()+"==>  ok");
    }
    private volatile static CLockLazyMan cLockLazyMan;
    public static CLockLazyMan getInstance(){
  //先判斷對象是否已經實例過，沒有實例過才進入加鎖代碼      
      if (cLockLazyMan==null){
          //對類對象進行加鎖
            synchronized (cLockLazyMan.class){
                if (cLockLazyMan==null){
                    cLockLazyMan = new CLockLazyMan();  //不是原子性操作
  /* 正確的指令順序
     1 分配記憶體空間
     2 執行構造方法 初始化對象
     3 把這個對象指向記憶體空間
     但 可能會出現 指令重排 即指令重排 返回cLockLazyMan還沒有初始化對象  因此還要加上volatile
  */
                }
            }
        }
        return cLockLazyMan;
    }
public static void main(String[] args) {
//        cLockLazyMan.getInstance();  // 單線程下 單例
//    雙重檢測鎖模式懶漢式 DCL懶漢式
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                cLockLazyMan.getInstance();
            }).start();
        }
    }
}

  正確的指令順序

      1 為cLockLazyMan分配記憶體空間

      2 執行構造方法 初始化cLockLazyMan對象

      3 把這個對象cLockLazyMan指向分配好的記憶體空間

  但由於JVM具有指令重排的特性 可能會出現 指令重排 1->3->2

       指令重排在單線程環境下不會出現問題，但多線程環境下可能會發生指令重排，會返回cLockLazyMan還沒有初始化對象 ，線程1執行1、3後，線程2執行調用getInstance()時，會發現cLockLazyMan不為空，並返回，但此時的cLockLazyMan還沒被初始化呢

   因此要對變數cLockLazyMan加上volatile，禁止JVM的指令重排，保證多線程下的正常允許。

 

靜態內部類單例

//靜態內部類
public class cHolder {
    private cHolder(){}
    private static cHolder getInstance(){
        return InnerClass.cHolder;
    }
    public static class InnerClass{
        private static final cHolder cHolder = new cHolder();
    }
}

枚舉（枚舉本身是單例） 枚舉沒有無參構造，是有參構造（String,int）

if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor;   // read volatile

 

5、CAS(Compare And Swap) 比較並交換 操作CPU原語（不可分割，連續不中斷 即保證原子性）

（1）CAS:可以解決多線程並行下使用鎖造成性能損耗的一種機制。

（2）CAS操作數（3個）：記憶體位置（V）和預期原值（A）以及新值（B）

（3）原理：

==簡意：比較當前工作記憶體中的值和主記憶體中的值，如果這個值是期望的，就執行操作，如果不是就一直迴圈。

==定義：

           如果記憶體位置的值（V）與預期的值（A）相匹配，處理器會自動將該位置的值設置為新值（B）；

           如果處理器不做任何操作，一個線程會從主記憶體中得到num值，並對num值進行操作，在寫入值時，線程會把第一次取到的num值和主存中的num值進行比較，如果相等，就會將改變後的num值寫入主記憶體中，如果不相等，就會一直迴圈對比，直到成功為止。

（4）理解CAS

例：使用原子類AtomicInteger進行理解

public static void main(String[] args) {
    //定義原子類型  定義為 2022
    AtomicInteger atomicInteger = new AtomicInteger(2022);
    //  public final boolean compareAndSet(int expect, int update)
    // 比較並更換     期望  更新    如果期望達到了就更新 否則不更新
    System.out.println(atomicInteger.compareAndSet(2022, 2023)); //true
    System.out.println(atomicInteger.get());  //2023 達到期望的2022   進行更換
    //再次 比較更換
    System.out.println(atomicInteger.compareAndSet(2022, 2023));  //false
    System.out.println(atomicInteger.get()); //2023 但沒有更換成功
}

==AtomicInteger的源碼,使用Unsafe類 native類，使用c++操作記憶體

 

 

 

 

 

 

==通過 原子類自增1的方法 理解CAS

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

 

 

 

（4）CAS的產生：修飾共用變數時會使用volatile關鍵字，volatile保證可見性和有序性，但無法保證原子性（多線程下會造成不安全的現象），利用CAS可以利用CPU原語（不可分割，連續不中斷）保證現場操作的原子性。

（5）優缺點：

==優點：樂觀鎖的思想，非阻塞的輕量級鎖，即一個線程的失敗或掛起不影響其它線程的失敗或掛起的演算法。

==缺點：

====底層是自旋鎖，自旋迴圈會產生消耗，迴圈時間開銷大，占用CPU資源

==== 一次性只能保證一個共用變數的原子性操作，對於多個共用變數操作時，迴圈CAS無法保證操作的原子性。

====可能會產生ABA問題（狸貓換太子）

例如：主存原A=1 線程1 CAS(1,2)，線程2 CAS(1,3)、CAS(3,1)

若線程2比線程1先執行，主存中A=1已經發生了改變了，但 線程1不知情（A=1已經不是原來的A=1了）

 

 

（6）解決問題

==1、解決自旋時間消耗開銷大的問題

====若JVM支持處理器的pause指令，就可以解決。

====pause指令的作用：[1]延遲流水線執行指令de-pipeline，使CPU不過多消耗執行資源，延遲時間取決於具體的實現版本。

[2]避免在退出迴圈時因記憶體順序衝突而引起CPU流水線被清空，從而提高CPU的執行效率

==2、解決一次性只能保證一個共用變數的原子操作的問題

====方法一：可以使用鎖，不使用CAS了

====方法二：可以把多個共用變數合併成一個共用變數用CAS操作

AtomicReference類保證引用對象間的原子性，可以把多個變數放在一個對象里來進行CAS操作。

==3、解決ABA問題

===方法一：添加版本號（樂觀鎖原理）

===方法二：AtomicStampedReference類 引用原子類（方法一的實際操作）

使用AtomicStampedReference的compareAndSet()方法：首先檢查當前引用是否等於預期引用，並且當前標誌是否等於預期標誌，如果全部相等，則以原子方式將該引用和該標誌的值設置為給定的更新值。

public AtomicStampedReference(V initialRef （期望）, int initialStamp（時間戳、版本）) 
 
public boolean compareAndSet(V expectedReference,//預期值
                             V newReference,//新值
                             int expectedStmap,//預期戳記
                             int newStmap //新戳記
                            )  

例：解決ABA問題

//解決ABA問題   原子引用 類似 樂觀鎖原理   有時間戳(版本號)
public class cCAStoABATest {
    public static void main(String[] args) {
        //如果泛型是包裝類 要註意對象的引用問題  範圍問題
        //正常工作中 一般引用的是一個對象 
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(4,1);
        new Thread(()->{
            //獲取當前時間戳 即版本號
            int stamp = atomicStampedReference.getStamp();
            System.out.println("a 1 ==> "+stamp);
​
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //CAS操作
            System.out.println("a 2"+atomicStampedReference.compareAndSet(4, 28, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a 2 ==> "+atomicStampedReference.getStamp());
            System.out.println("a 2"+atomicStampedReference.compareAndSet(28, 4, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a 3 ==> "+atomicStampedReference.getStamp());
        },"a").start();
        new Thread(()->{
            //獲取當前時間戳 即版本號
            int stamp = atomicStampedReference.getStamp();
            System.out.println("b 1 ==> "+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //stamp 不是原來的版本了 就會失敗
            System.out.println("b 2"+atomicStampedReference.compareAndSet(4, 28, stamp, stamp + 1));
            System.out.println("b 2 ==> "+atomicStampedReference.getStamp());
        },"b").start();
    }
}

 

（7）CAS使用時機：

==1、線程數較少、等待時間短，可以採用自旋鎖進行CAS

==2、線程數較大、等待時間長，不建議使用，占用CPU資源消耗高

 

6、Atomic原子類 （java.util.concurrent.atomic）juc包下

（1）原子：指一個操作時不可中斷的，即使是多線程的情況下，一個操作一旦開始，便不能被其它線程干擾。

（2）原子類：具有原子性\原子操作特征的類

（3）類型（4類）

基本類型：

===整型原子類：AtomicInteger

===長整型原子類：AtomicLong

===布爾型原子類：AtomicBoolean

數組類型：

===引用類型原子類：AtomicReference

===原子更新帶版本號的引用類型：AtomicStampedReference

用於解決原子的更新數據和數據的版本號，解決CAS的ABA問題

===原子更新帶有標記位的引用類型：AtomicMarkableReference

對象的屬性修改類型：

===原子更新整型欄位的更新器：AtomicIntegerFieldUpdater

===原子更新長整型欄位的更新器：AtomicLongFieldUpdater

===原子更新引用類型欄位的更新器：AtomicReferenceFieldUpdater

（4）Atomic類的線程安全原理——AtomicInteger類為例

==1、原理分析

AtomicInteger源碼：

// setup to use Unsafe.compareAndSwapInt for updates（更新操作時提供“比較並替換”的作用）
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
​
static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}
​
private volatile int value;

 

AtomicInteger類主要利用CAS+volatile+native方法保證原子操作，避免了synchronized的高開銷，執行效率提升。

==CAS原理：期望值和原值進行比較，相同則更新，不同則自旋

==UnSafe.objectFieldOffset()方法是一個本地native方法：用於拿到原值的記憶體地址，返回的是valueOffser

==value是一個volatile變數，使記憶體可見。


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

-Advertisement-
Play Games
更多相關文章
  • Dubbo 學習筆記
    分散式基礎理論 1. 什麼是分散式系統？ 分散式系統是若幹獨立電腦的集合，這些電腦對於用戶來說就像單個系統 2. 應用架構演變 單一應用架構 當網站流量很小時，只需一個應用，將所有功能都部署在一起，以減少部署節點和成本，適用於小型網站，小型管理系統 垂直應用架構 當訪問量逐漸增大，單一應用增加機 ...
  • 淺析AQS
    阻塞隊列 同步隊列 AQS 原理 數據結構 CLH 共用方式 設計模式 組件 自定義 ...
  • Makefile學習筆記
    1. makefile簡單介紹： ▶ Windows系統里的 Visual studio/Dev C++等IDE工具(Integrated Development Environment)將C語言的預處理、編譯、彙編、鏈接等過程集成在一起，而在Linux系統下需要編寫GCC命令才能完成編譯操作。當項 ...
  • 初學Java時沒有理解的一些概念
    背景 之前學Java屬於趕鴨子上架，草草學習基礎語法便直接做課程作業，許多概念問題仍不清楚，故在此梳理一下，主要參考廖雪峰和互聯網資料。 Java運行方式與JVM Java是介於編譯型語言(C++)和解釋型語言(Python)之間的。所有Java代碼先被編譯為.class文件，然後在Java虛擬機( ...
  • HashMap源碼個人理解
    HashMap<Integer, String> map = new HashMap<>();map.put(11,"張三");map.put(12,"李四");map.put(13,"王五");map.put(12,"趙六");map.put(14,"陳皮");System.out.println ...
  • Java8 新特性，打破你對介面的認知
    Java 8 之前，介面裡面只能寫抽象方法，不能寫實現方法 Java 8 開始是可以有方法實現的，可以在介面中添加預設方法和靜態方法 預設方法用 default 修飾，只能用在介面中，靜態方法用 static 修飾，並且介面中的預設方法、靜態方法可以同時有多個。 為什麼要用介面預設方法 舉一個很現實 ...
  • GO環境配置
    一、環境安裝及配置 引用鏈接：Go語言環境安裝及配置 Go版本安裝 百度網盤msi地址：版本v1.18.1提取碼：m1mc GoLand工具 鏈接：【版本2020.1】提取碼：7x9o 2.1、安裝流程 goland-2020.1.exe安裝 2.2、破解 先下載壓縮包解壓後得到jetbrains- ...
  • Python中的Super詳解
    這篇文章我們來介紹一下 super，我相信大部分的人使用 super 都是使用這種方式； # 就是我有一個 class 比如說是 Male，然後繼承另外一個 class 比如是 Person，然後我在這個 Male 也就是它的子類的 init 函數裡面用 super().__init__() 來調用 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類