主頁 > 後端開發 > Java多執行緒訪問Synchronized同步方法的八種使用場景

Java多執行緒訪問Synchronized同步方法的八種使用場景

2020-12-22 09:25:16 後端開發

簡介

本文將介紹7種同步方法的訪問場景，我們來看看這七種情況下，多執行緒訪問同步方法是否還是執行緒安全的，這些場景是多執行緒編程中經常遇到的，而且也是面試時高頻被問到的問題，所以不管是理論還是實踐，這些都是多執行緒場景必須要掌握的場景，

八種使用場景：

接下來，我們來通過代碼實作，分別判斷以下場景是不是執行緒安全的，以及原因是什么，

  1. 兩個執行緒同時訪問同一個物件的同步方法

  2. 兩個執行緒同時訪問兩個物件的同步方法

  3. 兩個執行緒同時訪問（一個或兩個）物件的靜態同步方法

  4. 兩個執行緒分別同時訪問（一個或兩個）物件的同步方法和非同步方法

  5. 兩個執行緒訪問同一個物件中的同步方法，同步方法又呼叫一個非同步方法

  6. 兩個執行緒同時訪問同一個物件的不同的同步方法

  7. 兩個執行緒分別同時訪問靜態synchronized和非靜態synchronized方法

  8. 同步方法拋出例外后，JVM會自動釋放鎖的情況

場景一：兩個執行緒同時訪問同一個物件的同步方法

分析：這種情況是經典的物件鎖中的方法鎖，兩個執行緒爭奪同一個物件鎖，所以會相互等待，是執行緒安全的，

兩個執行緒同時訪問同一個物件的同步方法，是執行緒安全的，
1
復制代碼

我們在前文中已經講過了，代碼和詳細講解在《Java中synchronized實作物件鎖的兩種方式及原理決議》中的第二部分《方法鎖》中，在此就不再重述了，

場景二：兩個執行緒同時訪問兩個物件的同步方法

這種場景就是物件鎖失效的場景，原因出在訪問的是兩個物件的同步方法，那么這兩個執行緒分別持有的兩個執行緒的鎖，所以是互相不會受限的，加鎖的目的是為了讓多個執行緒競爭同一把鎖，而這種情況多個執行緒之間不再競爭同一把鎖，而是分別持有一把鎖，所以我們的結論是：

兩個執行緒同時訪問兩個物件的同步方法，是執行緒不安全的，
1
復制代碼

代碼驗證：

public class Condition2 implements Runnable {
    // 創建兩個不同的物件
 static Condition2 instance1 = new Condition2();
 static Condition2 instance2 = new Condition2();

 @Override
 public void run() {
  method();
 }

 private synchronized void method() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，運行結束");
 }

 public static void main(String[] args) {
  Thread thread1 = new Thread(instance1);
  Thread thread2 = new Thread(instance2);
  thread1.start();
  thread2.start();
  while (thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測驗結束");
 }
}
123456789101112131415161718192021222324252627282930

運行結果：

兩個執行緒是并行執行的，所以執行緒不安全，

關注公眾號：程式員白楠楠，領取2020年末總結面試題

執行緒名：Thread-0，運行開始
執行緒名：Thread-1，運行開始
執行緒：Thread-0，運行結束
執行緒：Thread-1，運行結束
測驗結束
12345

代碼分析：

「問題在此：」兩個執行緒（thread1、thread2），訪問兩個物件（instance1、instance2）的同步方法（method()）,兩個執行緒都有各自的鎖，不能形成兩個執行緒競爭一把鎖的局勢，所以這時，synchronized修飾的方法method()和不用synchronized修飾的效果一樣（不信去把synchronized關鍵字去掉，運行結果一樣），所以此時的method()只是個普通方法，

「如何解決這個問題：」若要使鎖生效，只需將method()方法用static修飾，這樣就形成了類鎖，多個實體（instance1、instance2）共同競爭一把類鎖，就可以使兩個執行緒串行執行了，這也就是下一個場景要講的內容，

場景三：兩個執行緒同時訪問（一個或兩個）物件的靜態同步方法

這個場景解決的是場景二中出現的執行緒不安全問題，即用類鎖實作：

兩個執行緒同時訪問（一個或兩個）物件的靜態同步方法，是執行緒安全的，
1

關于此方法的代碼實作和詳細講解，參考文章《Java中synchronized實作類鎖的兩種方式及原理決議》中的第二部分《靜態方法鎖的方式實作類鎖》，在此不再重述，

場景四：兩個執行緒分別同時訪問（一個或兩個）物件的同步方法和非同步方法

這個場景是兩個執行緒其中一個訪問同步方法，另一個訪問非同步方法，此時程式會不會串行執行呢，也就是說是不是執行緒安全的呢？我們可以確定是執行緒不安全的，如果方法不加synchronized都是安全的，那就不需要同步方法了，驗證下我們的結論：

兩個執行緒分別同時訪問（一個或兩個）物件的同步方法和非同步方法，是執行緒不安全的，
1
public class Condition4 implements Runnable {

 static Condition4 instance = new Condition4();

 @Override
 public void run() {
  //兩個執行緒訪問同步方法和非同步方法
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //執行緒0,執行同步方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //執行緒1,執行非同步方法method1()
   method1();
  }
 }
    
    // 同步方法
 private synchronized void method0() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，同步方法，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，同步方法，運行結束");
 }
    
    // 普通方法
 private void method1() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，普通方法，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，普通方法，運行結束");
 }

 public static void main(String[] args) {
  Thread thread1 = new Thread(instance);
  Thread thread2 = new Thread(instance);
  thread1.start();
  thread2.start();
  while (thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測驗結束");
 }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

運行結果：

兩個執行緒是并行執行的，所以是執行緒不安全的，

執行緒名：Thread-0，同步方法，運行開始
執行緒名：Thread-1，普通方法，運行開始
執行緒：Thread-0，同步方法，運行結束
執行緒：Thread-1，普通方法，運行結束
測驗結束
12345
復制代碼

結果分析

「問題在于此：」 method1沒有被synchronized修飾，所以不會受到鎖的影響，即便是在同一個物件中，當然在多個實體中，更不會被鎖影響了，結論：

非同步方法不受其它由synchronized修飾的同步方法影響
1

你可能想到一個類似場景：多個執行緒訪問同一個物件中的同步方法，同步方法又呼叫一個非同步方法，這個場景會是執行緒安全的嗎？

場景五：兩個執行緒訪問同一個物件中的同步方法，同步方法又呼叫一個非同步方法

我們來實驗下這個場景，用兩個執行緒呼叫同步方法，在同步方法中呼叫普通方法；再用一個執行緒直接呼叫普通方法，看看是否是執行緒安全的？

public class Condition8 implements Runnable {

 static Condition8 instance = new Condition8();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //直接呼叫普通方法
   method2();
  } else {
   // 先呼叫同步方法，在同步方法內呼叫普通方法
   method1();
  }
 }

 // 同步方法
 private static synchronized void method1() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，同步方法，運行開始");
  try {
   Thread.sleep(2000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，同步方法，運行結束,開始呼叫普通方法");
  method2();
 }

 // 普通方法
 private static void method2() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，普通方法，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，普通方法，運行結束");
 }

 public static void main(String[] args) {
  // 此執行緒直接呼叫普通方法
  Thread thread0 = new Thread(instance);
  // 這兩個執行緒直接呼叫同步方法
  Thread thread1 = new Thread(instance);
  Thread thread2 = new Thread(instance);
  thread0.start();
  thread1.start();
  thread2.start();
  while (thread0.isAlive() || thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測驗結束");
 }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

運行結果：

執行緒名：Thread-0，普通方法，運行開始
執行緒名：Thread-1，同步方法，運行開始
執行緒：Thread-1，同步方法，運行結束,開始呼叫普通方法
執行緒名：Thread-1，普通方法，運行開始
執行緒：Thread-0，普通方法，運行結束
執行緒：Thread-1，普通方法，運行結束
執行緒名：Thread-2，同步方法，運行開始
執行緒：Thread-2，同步方法，運行結束,開始呼叫普通方法
執行緒名：Thread-2，普通方法，運行開始
執行緒：Thread-2，普通方法，運行結束
測驗結束
1234567891011

結果分析：

我們可以看出，普通方法被兩個執行緒并行執行，不是執行緒安全的，這是為什么呢？

因為如果非同步方法，有任何其他執行緒直接呼叫，而不是僅在呼叫同步方法時，才呼叫非同步方法，此時會出現多個執行緒并行執行非同步方法的情況，執行緒就不安全了，

對于同步方法中呼叫非同步方法時，要想保證執行緒安全，就必須保證非同步方法的入口，僅出現在同步方法中，但這種控制方式不夠優雅，若被不明情況的人直接呼叫非同步方法，就會導致原有的執行緒同步不再安全，所以不推薦大家在專案中這樣使用，但我們要理解這種情況，并且我們要用語意明確的、讓人一看就知道這是同步方法的方式，來處理執行緒安全的問題，

所以，最簡單的方式，是在非同步方法上，也加上synchronized關鍵字，使其變成一個同步方法，這樣就變成了《場景五：兩個執行緒同時訪問同一個物件的不同的同步方法》，這種場景下，大家就很清楚的看到，同一個物件中的兩個同步方法，不管哪個執行緒呼叫，都是執行緒安全的了，

所以結論是：

兩個執行緒訪問同一個物件中的同步方法，同步方法又呼叫一個非同步方法，僅在沒有其他執行緒直接呼叫非同步方法的情況下，是執行緒安全的，若有其他執行緒直接呼叫非同步方法，則是執行緒不安全的，
1

場景六：兩個執行緒同時訪問同一個物件的不同的同步方法

這個場景也是在探討物件鎖的作用范圍，物件鎖的作用范圍是物件中的所有同步方法，所以，當訪問同一個物件中的多個同步方法時，結論是：

兩個執行緒同時訪問同一個物件的不同的同步方法時，是執行緒安全的，
1
public class Condition5 implements Runnable {
 static Condition5 instance = new Condition5();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //執行緒0,執行同步方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //執行緒1,執行同步方法method1()
   method1();
  }
 }

 private synchronized void method0() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，同步方法0，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，同步方法0，運行結束");
 }

 private synchronized void method1() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，同步方法1，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，同步方法1，運行結束");
 }

 //運行結果:串行
 public static void main(String[] args) {
  Thread thread1 = new Thread(instance);
  Thread thread2 = new Thread(instance);
  thread1.start();
  thread2.start();
  while (thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測驗結束");
 }
}
12345678910111213141516171819202122232425262728293031323334353637383940414243444546

運行結果：

是執行緒安全的，

執行緒名：Thread-1，同步方法1，運行開始
執行緒：Thread-1，同步方法1，運行結束
執行緒名：Thread-0，同步方法0，運行開始
執行緒：Thread-0，同步方法0，運行結束
測驗結束
12345

結果分析：

兩個方法（method0()和method1()）的synchronized修飾符，雖沒有指定鎖物件，但默認鎖物件為this物件為鎖物件， 所以對于同一個實體（instance），兩個執行緒拿到的鎖是同一把鎖，此時同步方法會串行執行，這也是synchronized關鍵字的可重入性的一種體現，

場景七：兩個執行緒分別同時訪問靜態synchronized和非靜態synchronized方法

這種場景的本質也是在探討兩個執行緒獲取的是不是同一把鎖的問題，靜態synchronized方法屬于類鎖，鎖物件是（*.class）物件，非靜態synchronized方法屬于物件鎖中的方法鎖，鎖物件是this物件，兩個執行緒拿到的是不同的鎖，自然不會相互影響，結論：

兩個執行緒分別同時訪問靜態synchronized和非靜態synchronized方法，執行緒不安全，
1

代碼實作：

public class Condition6 implements Runnable {
 static Condition6 instance = new Condition6();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //執行緒0,執行靜態同步方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //執行緒1,執行非靜態同步方法method1()
   method1();
  }
 }

 // 重點：用static synchronized 修飾的方法，屬于類鎖，鎖物件為（*.class）物件，
 private static synchronized void method0() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，靜態同步方法0，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，靜態同步方法0，運行結束");
 }

 // 重點：synchronized 修飾的方法，屬于方法鎖，鎖物件為（this）物件，
 private synchronized void method1() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，非靜態同步方法1，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，非靜態同步方法1，運行結束");
 }

 //運行結果:并行
 public static void main(String[] args) {
  //問題原因： 執行緒1的鎖是類鎖（*.class）物件，執行緒2的鎖是方法鎖（this）物件,兩個執行緒的鎖不一樣，自然不會互相影響，所以會并行執行，
  Thread thread1 = new Thread(instance);
  Thread thread2 = new Thread(instance);
  thread1.start();
  thread2.start();
  while (thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測驗結束");
 }
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

運行結果：

執行緒名：Thread-0，靜態同步方法0，運行開始
執行緒名：Thread-1，非靜態同步方法1，運行開始
執行緒：Thread-1，非靜態同步方法1，運行結束
執行緒：Thread-0，靜態同步方法0，運行結束
測驗結束
12345

場景八：同步方法拋出例外后，JVM會自動釋放鎖的情況

本場景探討的是synchronized釋放鎖的場景：

只有當同步方法執行完或執行時拋出例外這兩種情況，才會釋放鎖，
1

所以，在一個執行緒的同步方法中出現例外的時候，會釋放鎖，另一個執行緒得到鎖，繼續執行，而不會出現一個執行緒拋出例外后，另一個執行緒一直等待獲取鎖的情況，這是因為JVM在同步方法拋出例外的時候，會自動釋放鎖物件，

代碼實作：

public class Condition7 implements Runnable {

 private static Condition7 instance = new Condition7();

 @Override
 public void run() {
  if (Thread.currentThread().getName().equals("Thread-0")) {
   //執行緒0,執行拋例外方法method0()
   method0();
  }
  if (Thread.currentThread().getName().equals("Thread-1")) {
   //執行緒1,執行正常方法method1()
   method1();
  }
 }

 private synchronized void method0() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  //同步方法中，當拋出例外時，JVM會自動釋放鎖，不需要手動釋放，其他執行緒即可獲取到該鎖
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，拋出例外，釋放鎖");
  throw new RuntimeException();

 }

 private synchronized void method1() {
  System.out.println("執行緒名：" + Thread.currentThread().getName() + "，運行開始");
  try {
   Thread.sleep(4000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("執行緒：" + Thread.currentThread().getName() + "，運行結束");
 }

 public static void main(String[] args) {
  Thread thread1 = new Thread(instance);
  Thread thread2 = new Thread(instance);
  thread1.start();
  thread2.start();
  while (thread1.isAlive() || thread2.isAlive()) {
  }
  System.out.println("測驗結束");
 }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

運行結果：

執行緒名：Thread-0，運行開始
執行緒名：Thread-0，拋出例外，釋放鎖
執行緒名：Thread-1，運行開始
Exception in thread "Thread-0" java.lang.RuntimeException
 at com.study.synchronize.conditions.Condition7.method0(Condition7.java:34)
 at com.study.synchronize.conditions.Condition7.run(Condition7.java:17)
 at java.lang.Thread.run(Thread.java:748)
執行緒：Thread-1，運行結束
測驗結束
123456789

結果分析：

可以看出執行緒還是串行執行的，說明是執行緒安全的，而且出現例外后，不會造成死鎖現象，JVM會自動釋放出現例外執行緒的鎖物件，其他執行緒獲取鎖繼續執行，

總結

本文總結了并用代碼實作和驗證了synchronized各種使用場景，以及各種場景發生的原因和結論，我們分析的理論基礎都是synchronized關鍵字的鎖物件究竟是誰？多個執行緒之間競爭的是否是同一把鎖？根據這個條件來判斷執行緒是否是安全的，所以，有了這些場景的分析鍛煉后，我們在以后使用多執行緒編程時，也可以通過分析鎖物件的方式，判斷出執行緒是否是安全的，從而避免此類問題的出現，

小編總結了2020面試題，這份面試題的包含的模塊分為19個模塊，分別是： Java 基礎、容器、多執行緒、反射、物件拷貝、Java Web 、例外、網路、設計模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM ，

關注公眾號：程式員白楠楠，獲取上述資料，



轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/238377.html

標籤：其他

上一篇：C 語言運算子與分支回圈小記

下一篇：檔案上傳下載小工具

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂