?

lock (new { }.GetType()){}

synchronized有兩種用法，一種是在方法定義時使用，多執行緒狀態下，這個方法只能同時被同一個執行緒執行；另一種就是你問到的這種情況，用於鎖定程式碼段，也就是說，{ }括號中的程式碼是不會同時被多個執行緒執行，而是排隊執行。
以上是回答Java的synchronized關鍵字，C#裡有lock對應，用來所著一個物件，其他執行緒只有等到被鎖住的物件lockObj被釋放以後，才可以執行括號中的內容。

　public static void main(String args[])  　{  　　Foo f1 = new Foo(1);  　　f1.start();  　　Foo f2 = new Foo(3); 　　f2.start();  　}  } 

　　執行SyncTest產生的輸出是1和3交叉的。如果printVal是斷面，你看到的輸出只能是1或者只能是3而不能是兩者同時出現。程式執行的結果證明兩個執行緒都在併發的執行printVal方法，即使該方法是同步的並且由於是一個無限迴圈而沒有終止。

類的同步：

要實現真正的斷面，你必須同步一個全域性物件或者對類進行同步。下面的程式碼給出了一個這樣的範例。

class Foo extends Thread  {  　private int val;  　public Foo(int v)  　{  　　val = v;  　}  　public void printVal(int v)  　{  　　synchronized(Foo.class) {  　　　while(true) 　　　　System.out.println(v);  　　}  　}  　public void run()  　{  　　printVal(val);  　}  } 

　　上面的類不再對個別的類例項同步而是對類進行同步。對於類Foo而言，它只有唯一的類定義，兩個執行緒在相同的鎖上同步，因此只有一個執行緒可以執行printVal方法。

　　這個程式碼也可以通過對公共物件加鎖。例如給Foo新增一個靜態成員。兩個方法都可以同步這個物件而達到執行緒安全。

面筆者給出一個參考實現，給出同步公共物件的兩種通常方法：

　　1、

class Foo extends Thread  {  　private int val; 　private static Object lock=new Object(); 　public Foo(int v)  　{  　　val = v;  　}  　public void printVal(int v)  　{  　　synchronized(lock) {  　　　while(true) 　　　　System.out.println(v);  　　}  　}  　public void run()  　{  　　printVal(val);  　}  }

　　上面的這個例子比原文給出的例子要好一些，因為原文中的加鎖是針對類定義的，一個類只能有一個類定義，而同步的一般原理是應該儘量減小同步的粒度以到達更好的效能。筆者給出的範例的同步粒度比原文的要小。

　　2、

class Foo extends Thread  { 　private String name; 　private String val; 　public Foo(String name,String v)  　{  　　this.name=name; 　　val = v;  　}  　public void printVal()  　{  　　synchronized(val) {  　　　while(true) System.out.println(name+val);  　　}  　}  　public void run()  　{  　　printVal();  　}  } public class SyncMethodTest  {  　public static void main(String args[])  　{  　　Foo f1 = new Foo("Foo 1:","printVal");  　　f1.start();  　　Foo f2 = new Foo("Foo 2:","printVal"); 　　f2.start();  　}  }

　　上面這個程式碼需要進行一些額外的說明，因為JVM有一種優化機制，因為String型別的物件是不可變的，因此當你使用""的形式引用字串時，如果JVM發現記憶體已經有一個這樣的物件，那麼它就使用那個物件而不再生成一個新的String物件，這樣是為了減小記憶體的使用。

　　上面的main方法其實等同於：

public static void main(String args[])  { 　String value="printVal"; 　Foo f1 = new Foo("Foo 1:",value);  　f1.start();  　Foo f2 = new Foo("Foo 2:",value); 　f2.start();  } 

總結：

1、synchronized關鍵字的作用域有二種：  1）是某個物件例項內，synchronized aMethod(){}可以防止多個執行緒同時訪問這個物件的synchronized方法（如果一個物件有多個synchronized方法，只要一個執行緒訪問了其中的一個synchronized方法，其它執行緒不能同時訪問這個物件中任何一個synchronized方法）。這時，不同的物件例項的synchronized方法是不相干擾的。也就是說，其它執行緒照樣可以同時訪問相同類的另一個物件例項中的synchronized方法；  2）是某個類的範圍，synchronized static aStaticMethod{}防止多個執行緒同時訪問這個類中的synchronized static 方法。它可以對類的所有物件例項起作用。

2、除了方法前用synchronized關鍵字，synchronized關鍵字還可以用於方法中的某個區塊中，表示只對這個區塊的資源實行互斥訪問。用法是: synchronized(this){/*區塊*/}，它的作用域是當前物件；

3、synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中並不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法；

Java語言的關鍵字，當它用來修飾一個方法或者一個程式碼塊的時候，能夠保證在同一時刻最多隻有一個執行緒執行該段程式碼。

     一、當兩個併發執行緒訪問同一個物件object中的這個synchronized(this)同步程式碼塊時，一個時間內只能有一個執行緒得到執行。另一個執行緒必須等待當前執行緒執行完這個程式碼塊以後才能執行該程式碼塊。

     二、然而，當一個執行緒訪問object的一個synchronized(this)同步程式碼塊時，另一個執行緒仍然可以訪問該object中的非synchronized(this)同步程式碼塊。

     三、尤其關鍵的是，當一個執行緒訪問object的一個synchronized(this)同步程式碼塊時，其他執行緒對object中所有其它synchronized(this)同步程式碼塊的訪問將被阻塞。

     四、第三個例子同樣適用其它同步程式碼塊。也就是說，當一個執行緒訪問object的一個synchronized(this)同步程式碼塊時，它就獲得了這個object的物件鎖。結果，其它執行緒對該object物件所有同步程式碼部分的訪問都被暫時阻塞。

     五、以上規則對其它物件鎖同樣適用.

第二篇：

synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。   1. synchronized 方法：通過在方法宣告中加入 synchronized關鍵字來宣告 synchronized 方法。如：   public synchronized void accessVal(int newVal);   synchronized 方法控制對類成員變數的訪問：每個類例項對應一把鎖，每個 synchronized 方法都必須獲得呼叫該方法的類例項的鎖方能

執行，否則所屬執行緒阻塞，方法一旦執行，就獨佔該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的執行緒方能獲得該鎖，重新進入可執行

狀態。這種機制確保了同一時刻對於每一個類例項，其所有宣告為 synchronized 的成員函式中至多隻有一個處於可執行狀態（因為至多隻有

一個能夠獲得該類例項對應的鎖），從而有效避免了類成員變數的訪問衝突（只要所有可能訪問類成員變數的方法均被宣告為 synchronized）

。   在 Java 中，不光是類例項，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函式宣告為 synchronized ，以控制其對類的靜態成

員變數的訪問。   synchronized 方法的缺陷：若將一個大的方法宣告為synchronized 將會大大影響效率，典型地，若將執行緒類的方法 run() 宣告為

synchronized ，由於線上程的整個生命期內它一直在執行，因此將導致它對本類任何 synchronized 方法的呼叫都永遠不會成功。當然我們可

以通過將訪問類成員變數的程式碼放到專門的方法中，將其宣告為 synchronized ，並在主方法中呼叫來解決這一問題，但是 Java 為我們提供

了更好的解決辦法，那就是 synchronized 塊。   2. synchronized 塊：通過 synchronized關鍵字來宣告synchronized 塊。語法如下：   synchronized(syncObject) {   //允許訪問控制的程式碼   }   synchronized 塊是這樣一個程式碼塊，其中的程式碼必須獲得物件 syncObject （如前所述，可以是類例項或類）的鎖方能執行，具體機

制同前所述。由於可以針對任意程式碼塊，且可任意指定上鎖的物件，故靈活性較高。   對synchronized(this)的一些理解  一、當兩個併發執行緒訪問同一個物件object中的這個synchronized(this)同步程式碼塊時，一個時間內只能有一個執行緒得到執行。另一個線

程必須等待當前執行緒執行完這個程式碼塊以後才能執行該程式碼塊。   二、然而，當一個執行緒訪問object的一個synchronized(this)同步程式碼塊時，另一個執行緒仍然可以訪問該object中的非synchronized

(this)同步程式碼塊。   三、尤其關鍵的是，當一個執行緒訪問object的一個synchronized(this)同步程式碼塊時，其他執行緒對object中所有其它synchronized(this)

同步程式碼塊的訪問將被阻塞。   四、第三個例子同樣適用其它同步程式碼塊。也就是說，當一個執行緒訪問object的一個synchronized(this)同步程式碼塊時，它就獲得了這個

object的物件鎖。結果，其它執行緒對該object物件所有同步程式碼部分的訪問都被暫時阻塞。   五、以上規則對其它物件鎖同樣適用

第三篇：

打個比方：一個object就像一個大房子，大門永遠開啟。房子裡有 很多房間（也就是方法）。

這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。房門口放著一把鑰匙（key），這把鑰匙可以開啟所有上鎖的房間。

另外我把所有想呼叫該物件方法的執行緒比喻成想進入這房子某個 房間的人。所有的東西就這麼多了，下面我們看看這些東西之間如何作用的。

在此我們先來明確一下我們的前提條件。該物件至少有一個synchronized方法，否則這個key還有啥意義。當然也就不會有我們的這個主題了。

一個人想進入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明暫時還沒有其他人要使用上鎖的 房間）。於是他走上去拿到了鑰匙

，並且按照自己 的計劃使用那些房間。注意一點，他每次使用完一次上鎖的房間後會馬上把鑰匙還回去。即使他要連續使用兩間上鎖的房間，

中間他也要把鑰匙還回去，再取回來。

因此，普通情況下鑰匙的使用原則是：“隨用隨借，用完即還。”

這時其他人可以不受限制的使用那些不上鎖的房間，一個人用一間可以，兩個人用一間也可以，沒限制。但是如果當某個人想要進入上鎖的房

間，他就要跑到大門口去看看了。有鑰匙當然拿了就走，沒有的話，就只能等了。

要是很多人在等這把鑰匙，等鑰匙還回來以後，誰會優先得到鑰匙？Not guaranteed。象前面例子裡那個想連續使用兩個上鎖房間的傢伙，他

中間還鑰匙的時候如果還有其他人在等鑰匙，那麼沒有任何保證這傢伙能再次拿到。 （JAVA規範在很多地方都明確說明不保證，象

Thread.sleep()休息後多久會返回執行，相同優先權的執行緒那個首先被執行，當要訪問物件的鎖被 釋放後處於等待池的多個執行緒哪個會優先得

到，等等。我想最終的決定權是在JVM，之所以不保證，就是因為JVM在做出上述決定的時候，絕不是簡簡單單根據 一個條件來做出判斷，而是

根據很多條。而由於判斷條件太多，如果說出來可能會影響JAVA的推廣，也可能是因為智慧財產權保護的原因吧。SUN給了個不保證 就混過去了

。無可厚非。但我相信這些不確定，並非完全不確定。因為計算機這東西本身就是按指令執行的。即使看起來很隨機的現象，其實都是有規律

可尋。學過 計算機的都知道，計算機裡隨機數的學名是偽隨機數，是人運用一定的方法寫出來的，看上去隨機罷了。另外，或許是因為要想弄

的確定太費事，也沒多大意義，所 以不確定就不確定了吧。）

再來看看同步程式碼塊。和同步方法有小小的不同。

1.從尺寸上講，同步程式碼塊比同步方法小。你可以把同步程式碼塊看成是沒上鎖房間裡的一塊用帶鎖的屏風隔開的空間。

2.同步程式碼塊還可以人為的指定獲得某個其它物件的key。就像是指定用哪一把鑰匙才能開這個屏風的鎖，你可以用本房的鑰匙；你也可以指定

用另一個房子的鑰匙才能開，這樣的話，你要跑到另一棟房子那兒把那個鑰匙拿來，並用那個房子的鑰匙來開啟這個房子的帶鎖的屏風。

         記住你獲得的那另一棟房子的鑰匙，並不影響其他人進入那棟房子沒有鎖的房間。

         為什麼要使用同步程式碼塊呢？我想應該是這樣的：首先對程式來講同步的部分很影響執行效率，而一個方法通常是先建立一些區域性變

量，再對這些變數做一些 操作，如運算，顯示等等；而同步所覆蓋的程式碼越多，對效率的影響就越嚴重。因此我們通常儘量縮小其影響範圍。

如何做？同步程式碼塊。我們只把一個方法中該同 步的地方同步，比如運算。

         另外，同步程式碼塊可以指定鑰匙這一特點有個額外的好處，是可以在一定時期內霸佔某個物件的key。還記得前面說過普通情況下鑰

匙的使用原則嗎。現在不是普通情況了。你所取得的那把鑰匙不是永遠不還，而是在退出同步程式碼塊時才還。

          還用前面那個想連續用兩個上鎖房間的傢伙打比方。怎樣才能在用完一間以後，繼續使用另一間呢。用同步程式碼塊吧。先建立另外

一個執行緒，做一個同步程式碼 塊，把那個程式碼塊的鎖指向這個房子的鑰匙。然後啟動那個執行緒。只要你能在進入那個程式碼塊時抓到這房子的鑰匙

，你就可以一直保留到退出那個程式碼塊。也就是說 你甚至可以對本房內所有上鎖的房間遍歷，甚至再sleep(10*60*1000)，而房門口卻還有

1000個執行緒在等這把鑰匙呢。很過癮吧。

          在此對sleep()方法和鑰匙的關聯性講一下。一個執行緒在拿到key後，且沒有完成同步的內容時，如果被強制sleep()了，那key還一

直在 它那兒。直到它再次執行，做完所有同步內容，才會歸還key。記住，那傢伙只是幹活幹累了，去休息一下，他並沒幹完他要乾的事。為

了避免別人進入那個房間 把裡面搞的一團糟，即使在睡覺的時候他也要把那唯一的鑰匙戴在身上。

          最後，也許有人會問，為什麼要一把鑰匙通開，而不是一個鑰匙一個門呢？我想這純粹是因為複雜性問題。一個鑰匙一個門當然更

安全，但是會牽扯好多問題。鑰匙 的產生，保管，獲得，歸還等等。其複雜性有可能隨同步方法的增加呈幾何級數增加，嚴重影響效率。這也

算是一個權衡的問題吧。為了增加一點點安全性，導致效 率大大降低，是多麼不可取啊。

synchronized的一個簡單例子

public class TextThread {

public static void main(String[] args) {     TxtThread tt = new TxtThread();     new Thread(tt).start();     new Thread(tt).start();     new Thread(tt).start();     new Thread(tt).start();  }  }

class TxtThread implements Runnable {  int num = 100;  String str = new String();

public void run() {     synchronized (str) {      while (num > 0) {

     try {        Thread.sleep(1);       } catch (Exception e) {        e.getMessage();       }       System.out.println(Thread.currentThread().getName()         + "this is " + num--);      }     }  }  }

上面的例子中為了製造一個時間差,也就是出錯的機會,使用了Thread.sleep(10)

Java對多執行緒的支援與同步機制深受大家的喜愛，似乎看起來使用了synchronized關鍵字就可以輕鬆地解決多執行緒共享資料同步問題。到底如

何？――還得對synchronized關鍵字的作用進行深入瞭解才可定論。

總的說來，synchronized關鍵字可以作為函式的修飾符，也可作為函式內的語句，也就是平時說的同步方法和同步語句塊。如果再細的分類，

synchronized可作用於instance變數、object reference（物件引用）、static函式和class literals(類名稱字面常量)身上。

在進一步闡述之前，我們需要明確幾點：

A．無論synchronized關鍵字加在方法上還是物件上，它取得的鎖都是物件，而不是把一段程式碼或函式當作鎖――而且同步方法很可能還會被其

他執行緒的物件訪問。

B．每個物件只有一個鎖（lock）與之相關聯。

C．實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以儘量避免無謂的同步控制。

接著來討論synchronized用到不同地方對程式碼產生的影響：

假設P1、P2是同一個類的不同物件，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以呼叫它們。

1． 把synchronized當作函式修飾符時，示例程式碼如下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時synchronized鎖定的是哪個物件呢？它鎖定的是呼叫這個同步方法物件。也就是說，當一個物件P1在不同的執行緒中

執行這個同步方法時，它們之間會形成互斥，達到同步的效果。但是這個物件所屬的Class所產生的另一物件P2卻可以任意呼叫這個被加了

synchronized關鍵字的方法。

上邊的示例程式碼等同於如下程式碼：

public void methodAAA()

{

synchronized (this)      // (1)

{

       //…..

}

}

(1)處的this指的是什麼呢？它指的就是呼叫這個方法的物件，如P1。可見同步方法實質是將synchronized作用於object reference。――那個

拿到了P1物件鎖的執行緒，才可以呼叫P1的同步方法，而對P2而言，P1這個鎖與它毫不相干，程式也可能在這種情形下襬脫同步機制的控制，造

成資料混亂：（

2．同步塊，示例程式碼如下：

public void method3(SomeObject so)

{

    synchronized(so)

    {         //…..      }

}

這時，鎖就是so這個物件，誰拿到這個鎖誰就可以執行它所控制的那段程式碼。當有一個明確的物件作為鎖時，就可以這樣寫程式，但當沒有明

確的物件作為鎖，只是想讓一段程式碼同步時，可以建立一個特殊的instance變數（它得是一個物件）來充當鎖：

class Foo implements Runnable

{

        private byte[] lock = new byte[0]; // 特殊的instance變數

        Public void methodA()          {

           synchronized(lock) { //… }

        }

        //…..

}

注：零長度的byte陣列物件建立起來將比任何物件都經濟――檢視編譯後的位元組碼：生成零長度的byte[]物件只需3條操作碼，而Object lock

= new Object()則需要7行操作碼。

3．將synchronized作用於static 函式，示例程式碼如下：

Class Foo  {

    public synchronized static void methodAAA()   // 同步的static 函式      {          //….      }

    public void methodBBB()      {

       synchronized(Foo.class)   // class literal(類名稱字面常量)

    }  }

   程式碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函式產生的效果是一樣的，取得的鎖很特別，是當前呼叫這

個方法的物件所屬的類（Class，而不再是由這個Class產生的某個具體物件了）。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用於作同步鎖還不一樣，不能用P1.getClass()來達到鎖這個Class的

目的。P1指的是由Foo類產生的物件。

可以推斷：如果一個類中定義了一個synchronized的static函式A，也定義了一個synchronized 的instance函式B，那麼這個類的同一物件Obj

在多執行緒中分別訪問A和B兩個方法時，不會構成同步，因為它們的鎖都不一樣。A方法的鎖是Obj這個物件，而B的鎖是Obj所屬的那個Class。

小結如下：

搞清楚synchronized鎖定的是哪個物件，就能幫助我們設計更安全的多執行緒程式。

還有一些技巧可以讓我們對共享資源的同步訪問更加安全：

1． 定義private 的instance變數+它的 get方法，而不要定義public/protected的instance變數。如果將變數定義為public，物件在外界可以

繞過同步方法的控制而直接取得它，並改動它。這也是JavaBean的標準實現方式之一。

2． 如果instance變數是一個物件，如陣列或ArrayList什麼的，那上述方法仍然不安全，因為當外界物件通過get方法拿到這個instance物件

的引用後，又將其指向另一個物件，那麼這個private變數也就變了，豈不是很危險。 這個時候就需要將get方法也加上synchronized同步，並

且，只返回這個private物件的clone()――這樣，呼叫端得到的就是物件副本的引用了

java中可以使用Lock和Synchronized的可以實現對某個共享資源的同步，同時也可以實現對某些過程的原子性操作 
Lock可以使用Condition進行執行緒之間的排程 
Synchronized則使用Object物件本身的notify, wait, notityAll排程機制 
這兩種排程機制有什麼異同呢？ 
Condition是Java5以後出現的機制，它有更好的靈活性，而且在一個物件裡面可以有多個Condition（即物件監視器),則執行緒可以註冊在不同的Condition，從而可以有選擇性的排程執行緒，更加靈活。 
Synchronized就相當於整個物件只有一個單一的Condition（即該物件本身）所有的執行緒都註冊在它身上，執行緒排程的時候之後排程所有得註冊執行緒，沒有選擇權，會出現相當大的問題 
下面是一個場景，針對這個場景提出兩種解決方案。 
一箇中轉站，可以接納貨物，然後發出貨物，這是需要建一個倉庫，相當於一個緩衝區，當倉庫滿的時候，不能接貨，倉庫空的時候，不能發貨。 
第一種，用一個Condition去解決，有可能會出問題 

Java程式碼  

1. package com.zxx;  
2. import java.util.Random;  
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.locks.Condition;  
6. import java.util.concurrent.locks.Lock;  
7. import java.util.concurrent.locks.ReentrantLock;  
8. /** 
9.  * 單個Condition去控制一個緩衝區，多執行緒對緩衝區做讀寫操作，要保證緩衝區滿的時侯不會 
10.  * 被寫，空的時候不會被讀；單個Condition控制會出錯誤： 當緩衝區還有一個位置時，多個寫執行緒 
11.  * 同時訪問，則只有一個寫執行緒可以對其進行寫操作，操作完之後，喚醒在這個condition上等待的 
12.  * 其他幾個寫執行緒，如果判斷用IF語句的話就會出現繼續向緩衝區新增。 
13.  * @author Administrator 
14.  * 
15.  */  
16. public class ConditionError {  
17.     Lock lock = new ReentrantLock();  
18.     Condition condition = lock.newCondition();  
19.     String[] container = new String[10];  
20.     int index = 0;  
21.     public static void main(String[] args) {  
22.         ConditionError conditionError = new ConditionError();  
23.         conditionError.test();  
24.     }  
25.     public void test(){  
26.         ExecutorService threadPool = Executors.newCachedThreadPool();  
27.         for(int i = 0; i < 14; i++){//先用14個執行緒去寫，則有4個執行緒會被阻塞  
28.             threadPool.execute(new Runnable(){  
29.                 @Override  
30.                 public void run() {  
31.                     put();  
32.                 }  
33.             });  
34.         }  
35.         Executors.newSingleThreadExecutor().execute(new Runnable(){//用一個執行緒去取，則會通知4個阻塞的寫執行緒工作，此時  
36.                                                                 //會有一個執行緒向緩衝區寫，寫完後去通知在這個condition上等待  
37.                                                                 //的取執行緒，這是它的本意，但是它喚醒了寫執行緒，因為只有一個condition  
38.                                                                 //不能有選擇的喚醒寫取執行緒，此時就需要有多個Condition  
39.             @Override  
40.             public void run() {  
41.                 try {  
42.                     Thread.sleep(10000);  
43.                 } catch (InterruptedException e) {  
44.                     e.printStackTrace();  
45.                 }  
46.                 get();  
47.             }  
48. 相關推薦

    同步鎖定Java synchronized詳解（C#翻譯）

    ? lock (new { }.GetType()){} synchronized有兩種用法，一種是在方法定義時使用，多執行緒狀態下，這個方法只能同時被同一個執行緒執行；另一種就是你問到的這種情況，用於鎖定程式碼段，也就是說，{ }括

    VS2010 Chart控件（一）Chart控件在ASP.NET網站中的應用示例詳解（C#語言）

    [1] 設置 cti write conf int 應用程序 itl config 步驟如下： 1、 Chart控件（一）Chart控件在ASP.NET網站中的應用示例詳解（C#語言）" title="VS2010 Chart控件（一）Chart控件在ASP.NET網站中的

    Shapley演算法解決舞伴問題過程詳解（C++實現）

    舞伴問題是這樣的：有 n 個男孩與 n 個女孩參加舞會，每個男孩和女孩均交給主持一個名單，寫上他（她）中意的舞伴名字。無論男孩還是女孩，提交給主持人的名單都是按照偏愛程度排序的，排在前面的都是他們最中意的舞伴。試問主持人在收到名單後，是否可以將他們分成 n 對，使每個人都能和他們中意的舞伴結對跳舞？為了避免舞

    阿拉伯數字轉中文數字方法詳解（C++實現）

    阿拉伯數字與中文數字沒有一一對應關係，不存在直接轉換的公式化演算法，因此需要根據兩種數字體系的特點精心構造轉換演算法。 中文計數有一個特點，就是“零”的使用變化多端。阿拉伯數字中數字的權位依靠數字在整個數字長度中的偏移位置確定，因此數字中間出現的0用於標記數字的偏移位置，即便是連續出現的0也不能省略。中文計

    插入排序演算法詳解（C++實現）

    插入排序 輸入：n個數（a1,a2,...,an）。 輸出：輸入序列的一個排列（a1',a2',...,an'），使得a1'到an'為有序序列。 待排序的數稱為關鍵字key。 插入排序與平時生活中打牌時，整理手中牌的順序相似。最開始手中沒有牌，我們從桌上摸起一張牌，將它

    常用的排序演算法詳解（C#版）

    只要是搞程式設計的演算法、資料結構、作業系統、計算機組成原理這些東西都會有用到，就像醫生給人治病一樣，只有瞭解了人的內部機理、運作機制，才能很好的做到對症下藥，藥到病除。而上面所說的那些計算機理論課就好像人的內部機理一樣，我們往往都把這些東西給忽略了，而把更多的精力放在具體的程式語言實現上，當然我也是這樣，

    Java併發——執行緒同步Volatile與Synchronized詳解

    0. 前言 轉載請註明出處：http://blog.csdn.net/seu_calvin/article/details/52370068 面試時很可能遇到這樣一個問題：使用volatile修飾int型變數i，多個執行緒同時進行i++操作，這樣可以實現執行緒安全嗎？提到

    Java: synchronized詳解，靜態同步方法，普通同步方法，同步程式碼塊

    對程式碼進行同步控制我們可以選擇同步方法，也可以選擇同步塊，這兩種方式各有優缺點，至於具體選擇什麼方式，就見仁見智了，同步塊不僅可以更加精確的控制物件鎖，也就是控制鎖的作用域，何謂鎖的作用域？鎖的作用域就是從鎖被獲取到其被釋放的時間。而且可以選擇要獲取哪個物

    Java synchronized詳解

    ret 內置 etc 優先權 one lan string 作用域 靜態成員函數 轉自：http://www.cnblogs.com/devinzhang/archive/2011/12/14/2287675.html 第一篇： 使用synchronized 在編寫一個

    Java Scanner 類詳解（附例子）學習

    在筆試程式設計過程中，關於資料的讀取如果迷迷糊糊，那後來的程式設計即使想法很對，實現很好，也是徒勞，於是在這裡認真總結了Java  Scanner 類的使用 通過 Scanner 類來獲取使用者的輸入，下面是建立 Scanner 物件的基本語法： Scanner s =

    Java 開發必備面試題詳解（技術+人事）

    作為一名程式猿，無論新手還是老司機，面試求職始終是你需要直面的一件事情。首先梳理自己的知識體系，針對性準備，會有事半功倍的效果。我們往往會把重點放在技術上，而忽略了人事部分，實際上人事面試也會影響到最終的結果，把每一個環節做好，最終的結果自然不會差。 本 Chat 就為大家提供了一份詳盡的 Jav

    “全棧2019”Java第二十八章：陣列詳解（上篇）

    難度 初級 學習時間 10分鐘 適合人群 零基礎 開發語言 Java 開發環境 JDK v11 IntelliJ IDEA v2018.3 文章原文連結 “全棧2019”Java第二十八章：陣列詳解（上篇） 下一章 “全棧2019”Java第二十九章：陣列詳解（中篇）

    Java IO詳解（三)------位元組輸入輸出流

    那麼這篇部落格我們講的是位元組輸入輸出流：InputStream、OutputSteam(下圖紅色長方形框內)，紅色橢圓框內是其典型實現（FileInputSteam、FileOutStream） 　　    1、位元組輸出流：OutputStream

    Java NIO 詳解（一）

    一、基本概念描述 1.1 I/O簡介 I/O即輸入輸出，是計算機與外界世界的一個藉口。IO操作的實際主題是作業系統。在java程式設計中，一般使用流的方式來處理IO，所有的IO都被視作是單個位元組的移動，通過stream物件一次移動一個位元組。流IO負責把物件轉換為位元組

    Java NIO 詳解（二）

    在我的上一篇文章JavaNIO詳解（一）中介紹了關於標準輸入輸出NIO相關知識， 本篇將重點介紹基於網路程式設計NIO（非同步IO）。 非同步IO 非同步 I/O 是一種沒有阻塞地讀寫資料的方法。通常，在程式碼進行 read() 呼叫時，程式碼會阻塞直至有可供讀取的資料。

    Java多執行緒---阻塞佇列詳解（舉例說明）

    一. 前言 　　在新增的Concurrent包中，BlockingQueue很好的解決了多執行緒中，如何高效安全“傳輸”資料的問題。通過這些高效並且執行緒安全的佇列類，為我們快速搭建高質量的多執行緒程式帶來極大的便利。本文詳細介紹了BlockingQueue家庭中的所有成員

    【Java入門提高篇】Day34 Java容器類詳解（十五）WeakHashMap詳解

    public class WeakHashMapTest { public static void main(String[] args){ testWeakHashMap(); } private static void testWeakHashMap

    Java IO詳解（六)------序列化與反序列化（物件流）

    1、什麼是序列化與反序列化？ 序列化：指把堆記憶體中的 Java 物件資料，通過某種方式把物件儲存到磁碟檔案中或者傳遞給其他網路節點（在網路上傳輸）。這個過程稱為序列化。通俗來說就是將資料結構或物件轉換成二進位制串的過程 　　反序列化：把磁碟檔案中

    連結串列的插入和刪除操作詳解（C語言實現+詳解註釋）

    連結串列的基本操作中，連結串列結點的插入和刪除相對比較複雜，需根據結點插入位置的不同，使用合理的方法在不破壞原連結串列結構的前提下將其插入到連結串列中。 本節將詳解介紹這兩種操作的具體實現方法，讀者只需牢記實現步驟，即可輕鬆解決這兩大難點。 連結串列中插入結點 連結串列中插入結點，根據插入位置的不同，可

    靜態連結串列插入和刪除操作詳解（C語言程式碼實現）

    本節主要講解靜態連結串列的插入和刪除操作，有關靜態連結串列的詳細講解請閱讀《靜態連結串列及C語言實現》一文。 在講解靜態連結串列的插入和刪除操作之前，我們假設有如下的靜態連結串列： 圖中，array[0] 用作備用連結串列的頭結點，array[1] 用作存放資料的連結串列的頭結點，array[0]