java同步

『壹』 java中線程同步的幾種方法

java中多線程的實現方法有兩種：1.直接繼承thread類；2.實現runnable介面；同步的實現方法有五種：1.同步方法；2.同步代碼塊；3.使用特殊域變數(volatile)實現線程同步；4.使用重入鎖實現線程同步；5.使用局部變數實現線程同步 。
其中多線程實現過程中需注意重寫或者覆蓋run()方法，而對於同步的實現方法中使用較常使用的是利用synchronized編寫同步方法和代碼塊。

『貳』 java中什麼同步什麼是非同步分別用在什麼地方

java同步指的是synchronized機制，而非synchronized的都是非同步，弄懂同步的概念就大致明白了兩者的差別。

有關同步：
synchronized用來修飾一個方法或者一個代碼塊，它用來保證在同一時刻最多隻有一個線程執行該段代碼。
一、當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程得到執行。另一個線程必須等待當前線程執行完這個代碼塊以後才能執行該代碼塊。
二、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。
三、尤其關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。
四、第三個例子同樣適用其它同步代碼塊。也就是說，當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。
五、以上規則對其它對象鎖同樣適用。

示例代碼：
public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}
結果：
A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

『叄』 Java同步的問題

wait()與notify()是協同配合使用的,一個阻塞一個喚醒,你沒理解是因為你沒遇到這樣的需求!

我通俗的舉個例子:
比如胖子與瘦子兩個人(兩個線程)同時去吃饅頭(執行同一個方法),
假設方法裡面是饅頭,如果方法上鎖了後,這個吃的順序就是隨機的了
誰搶到就誰吃,有時候某一個人會連續好幾次吃到懂了嗎?

那現在變換一下思路,讓胖子與瘦子合作去生產饅頭,一個做,一個蒸,懂了嗎?後者必須要
等前者做好了才可以蒸啊,對么?如果你還用開始的思路都去爭奪這個方法,會造成死鎖情況,
比如瘦子來了,沒有饅頭它也要蒸,就在裡面死等..不出來!
這個時候wait與notify就派上用場了,胖子進來看沒饅頭就開始做,有饅頭就阻塞,notify喚醒瘦子
可以蒸饅頭了,瘦子完成以後,看沒饅頭了,就阻塞,notify喚醒胖子起來做..

(這一系列的動作,需要做一個旗標,進行切換判斷,即可完成是否wait還是notify)

大體就這么個意思...寫的比較粗糙.....

『肆』 java里同步是什麼意思

一般有兩種方法 同步方法和同步代碼塊

假設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。

『伍』 java中同步和非同步有什麼異同

Java中交互方式分為同步和非同步兩種：

相同的地方：

都屬於交互方式，都是發送請求。

不同的地方：

同步交互：指發送一個請求,需要等待返回,然後才能夠發送下一個請求，有個等待過程；

非同步交互：指發送一個請求,不需要等待返回,隨時可以再發送下一個請求，即不需要等待。區別：一個需要等待，一個不需要等待，在部分情況下，我們的項目開發中都會優先選擇不需要等待的非同步交互方式。

(5)java同步擴展閱讀：

Java，是由Sun Microsystems公司於1995年5月推出的Java程序設計語言和Java平台的總稱。用Java實現的HotJava瀏覽器（支持Java applet）顯示了Java的魅力：跨平台、動態的Web、Internet計算。從此，Java被廣泛接受並推動了Web的迅速發展，常用的瀏覽器現均支持Java applet

Java是一種簡單的，面向對象的，分布式的，解釋型的，健壯安全的，結構中立的，可移植的，性能優異、多線程的動態語言。

當1995年SUN推出Java語言之後，全世界的目光都被這個神奇的語言所吸引。那麼Java到底有何神奇之處呢？

Java語言其實最早誕生於1991年，起初被稱為OAK語言，是SUN公司為一些消費性電子產品而設計的一個通用環境。他們最初的目的只是為了開發一種獨立於平台的軟體技術，而且在網路出現之前，OAK可以說是默默無聞，甚至差點夭折。但是，網路的出現改變了OAK的命運。

參考資料:java基礎 網路

『陸』 java 裡面的同步是啥意思

樓主的理解完全正確。不過同步也會耗費額外的資源，所以Vector已經不建議使用了，用List來代替Vector的功能，並在必要的時候使用synchronized實現同步。

『柒』 java中同步的幾種方法

Java的同步可以用synchronized關鍵字來實現。

sychronized可以同步代碼，需要綁定一個對象，如synchronized(obj){}
也可以同步一個方法，是對方法進行線程同步。如public void synchronized methodA(){}

『捌』 java 方法同步

設置三個同步變數不就完了，然後synchronized的時候就同步這三個變數區分就行了

『玖』 java中同步有幾種方式啊

1。同步代碼塊：
synchronized(同一個數據){} 同一個數據：就是N條線程同時訪問一個數據。
2。
同步方法：
public synchronized 數據返回類型 方法名(){}
就
是使用 synchronized 來修飾某個方法，則該方法稱為同步方法。對於同步方法而言，無需顯示指定同步監視器，同步方法的同步監視器是
this
也就是該對象的本身（這里指的對象本身有點含糊，其實就是調用該同步方法的對象）通過使用同步方法，可非常方便的將某類變成線程安全的類，具有如下特徵：
1，該類的對象可以被多個線程安全的訪問。
2，每個線程調用該對象的任意方法之後，都將得到正確的結果。
3，每個線程調用該對象的任意方法之後，該對象狀態依然保持合理狀態。
註：synchronized關鍵字可以修飾方法，也可以修飾代碼塊，但不能修飾構造器，屬性等。
實現同步機制注意以下幾點： 安全性高，性能低，在多線程用。性能高，安全性低，在單線程用。
1，不要對線程安全類的所有方法都進行同步，只對那些會改變共享資源方法的進行同步。
2，如果可變類有兩種運行環境，當線程環境和多線程環境則應該為該可變類提供兩種版本：線程安全版本和線程不安全版本(沒有同步方法和同步塊)。在單線程中環境中，使用線程不安全版本以保證性能，在多線程中使用線程安全版本.

線程通訊：
為什麼要使用線程通訊？
當
使用synchronized
來修飾某個共享資源時(分同步代碼塊和同步方法兩種情況）,當某個線程獲得共享資源的鎖後就可以執行相應的代碼段，直到該線程運行完該代碼段後才釋放對該

共享資源的鎖，讓其他線程有機會執行對該共享資源的修改。當某個線程佔有某個共享資源的鎖時，如果另外一個線程也想獲得這把鎖運行就需要使用wait()
和notify()/notifyAll()方法來進行線程通訊了。
Java.lang.object 里的三個方法wait() notify() notifyAll()
wait方法導致當前線程等待，直到其他線程調用同步監視器的notify方法或notifyAll方法來喚醒該線程。
wait(mills)方法
都是等待指定時間後自動蘇醒，調用wait方法的當前線程會釋放該同步監視器的鎖定，可以不用notify或notifyAll方法把它喚醒。
notify()
喚醒在同步監視器上等待的單個線程，如果所有線程都在同步監視器上等待，則會選擇喚醒其中一個線程，選擇是任意性的，只有當前線程放棄對該同步監視器的鎖定後，也就是使用wait方法後，才可以執行被喚醒的線程。
notifyAll()方法
喚醒在同步監視器上等待的所有的線程。只用當前線程放棄對該同步監視器的鎖定後，才可以執行被喚醒的線程

『拾』 java同步和非同步的區別

java同步和非同步的區別如下：

一、根據情況需要專門的線程方式

如果數據將在線程間共享.例如正在寫的數據以後可能被另一個線程讀到,或者正在讀的數據可能已經被另一個線程寫過了,那麼這些數據就是共享數據,必須進行同步存取.

當應用程序在對象上調用了一個需要花費很長時間來執行的方法,並且不希望讓程序等待方法的返回時,就應該使用非同步編程,在很多情況下採用非同步途徑往往更有效率.

二、應用不同：

• Java同步:

  基本概念:每個Object都會有1個鎖.同步就是串列使用一些資源.

(說明:以下有些例子為了突出重點,省略了不必要的代碼.非凡是省掉了一些成員變數,就是需要同步的對象.)

1. 多線程中對共享、可變的數據進行同步.

對於函數中的局部變數沒必要進行同步.

對於不可變數據,也沒必要進行同步.

多線程中訪問共享可變數據才有必要.

2. 單個線程中可以使用synchronized,而且可以嵌套,但無意義.

class Test {

public static void main(String[] args) {

Test t = new Test();

synchronized(t) {

synchronized(t) {

System.out.println("ok!");

}

}

}

}

3. 對象實例的鎖

class Test{

public synchronized void f1(){

//do something here

}

public void f2(){

synchronized(this){

//do something here

}

}

}

上面的f1()和f2()效果一致, synchronized取得的鎖都是Test某個實列(this)的鎖.

比如: Test t = new Test();

線程A調用t.f2()時, 線程B無法進入t.f1(),直到t.f2()結束.

作用: 多線程中訪問Test的同一個實例的同步方法時會進行同步.

4. class的鎖

class Test{

final static Object o= new Object();

public static synchronized void f1(){

//do something here

}

public static void f2(){

synchronized(Test.class){

//do something here

}

}

public static void f3(){

try {

synchronized (Class.forName("Test")) {

//do something here

}

}

catch (ClassNotFoundException ex) {

}

}

public static void g(){

synchronized(o){

//do something here

}

}

}

上面f1(),f2(),f3(),g()效果一致

f1(),f2(),f3()中synchronized取得的鎖都是Test.class的鎖.

g()是自己產生一個對象o,利用o的鎖做同步

作用: 多線程中訪問此類或此類任一個實例的同步方法時都會同步. singleton模式lazily initializing屬於此類.

5. static method

class Test{

private static int v = 0;

public static void f1(){

//do something, 但函數中沒用用到v

}

public synchronized static void f2(){

//do something, 函數中對v進行了讀/寫.

}

}

多線程中使用Test的某個實列時,

(1) f1()是線程安全的,不需要同步

(2) f2()這個靜態方法中使用了函數外靜態變數,所以需要同步.

• Java非同步:

  1、 它要能適應不同類型的請求:

  本節用 makeString來說明要求有返回值的請求.用displayString來說明不需要返回值的請求.

  2、 要能同時並發處理多個請求,並能按一定機制調度:

  本節將用一個隊列來存放請求,所以只能按FIFO機制調度,你可以改用LinkedList,就可以簡單實現一個優先順序(優先順序高的addFirst,低的addLast).

  3、有能力將調用的邊界從線程擴展到機器間(RMI)

  4、分離過度耦合,如分離調用句柄(取貨憑證)和真實數據的實現.分離調用和執行的過程,可以盡快地將調返回.

  現在看具體的實現:

  public interface Axman {

  Result resultTest(int count,char c);

  void noResultTest(String str);

  }

  這個介面有兩個方法要實現,就是有返回值的調用resultTest和不需要返回值的調用

  noResultTest, 我們把這個介面用一個代理類來實現,目的是將方法調用轉化為對象,這樣就可以將多個請求(多個方法調)放到一個容器中緩存起來,然後統一處理,因為 Java不支持方法指針,所以把方法調用轉換為對象,然後在這個對象上統一執行它們的方法,不僅可以做到非同步處理,而且可以將代表方法調用的請求對象序列化後通過網路傳遞到另一個機器上執行(RMI).這也是Java回調機制最有力的實現.

  一個簡單的例子.

  如果 1: 做A

  如果 2: 做B

  如果 3: 做C

  如果有1000個情況,你不至於用1000個case吧?以後再增加呢?

  所以如果C/C++程序員,會這樣實現: (c和c++定義結構不同)

  type define struct MyStruct{

  int mark;

  (*fn) ();

  } MyList;

  然後你可以聲明這個結構數據:

  {1,A,

  2,B

  3,C

  }

  做一個循環:

  for(i=0;i<length;i++) {

  if(數據組[i].mark == 傳入的值) (數據組[i].*fn)();

  }

  簡單說c/c++中將要被調用的涵數可以被保存起來,然後去訪問,調用,而Java中,我們無法將一個方法保存,除了直接調用,所以將要調用的方法用子類來實現,然後把這些子類實例保存起來,然後在這些子類的實現上調用方法:

  interface My{

  void test();

• }