java的多線程不異步怎么辦

可使用同步組件CountDownLatch、CyclicBarrier等使異程同步。Java異步會導致代碼出現諸多不可控因素，這時可可使用同步組件CountDownLatch、CyclicBarrier等進行修復。多線程并發時，多個線程同時請求同一個資源，必然導致此資源的數據不安全，A線程修改了B線程的處理的數據，而B線程又修改了A線程處理的數理。顯然這是由于全局資源造成的，有時為了解決此問題，優先考慮使用局部變量，退而求其次使用同步代碼塊，出于這樣的安全考慮就必須犧牲系統處理性能，加在多線程并發時資源掙奪最激烈的地方，這就實現了線程的同步機制。

站在用戶的角度思考問題，與客戶深入溝通，找到沛縣網站設計與沛縣網站推廣的解決方案，憑借多年的經驗，讓設計與互聯網技術結合，創造個性化、用戶體驗好的作品，建站類型包括：成都做網站、成都網站建設、企業官網、英文網站、手機端網站、網站推廣、國際域名空間、虛擬空間、企業郵箱。業務覆蓋沛縣地區。

求 JAVA 異步觀察者模式 的源代碼（完整的），不要同步的，好的給加分

package TestObserver;

import java.util.Iterator;

import java.util.Vector;

/**

*

* @author Seastar

*/

interface Observed {

public void addObserver(Observer o);

public void removeObserver(Observer o);

public void update();

}

interface Observer {

public void takeAction();

}

class Invoker {

private Observer o;

Handler handler;

public Invoker(Observer o) {

new Handler();

this.o = o;

}

private class Handler extends Thread {

public Handler() {

handler = this;

}

@Override

public void run() {

o.takeAction();

}

}

public boolean TestSameObserver(Observer o) {

return o == this.o;

}

public void invoke() {

handler.start();

}

}

class ObservedObject implements Observed {

private VectorInvoker observerList = new VectorInvoker();

public void addObserver(Observer o) {

observerList.add(new Invoker(o));

}

public void removeObserver(Observer o) {

IteratorInvoker it = observerList.iterator();

while (it.hasNext()) {

Invoker i = it.next();

if (i.TestSameObserver(o)) {

observerList.remove(i);

break;

}

}

}

public void update() {

for (Invoker i : observerList) {

i.invoke();

}

}

}

class ObserverA implements Observer {

public void takeAction() {

System.out.println("I am Observer A ,state changed ,so i have to do something");

}

}

class ObserverB implements Observer {

public void takeAction() {

System.out.println("I am Observer B ,i was told to do something");

}

}

class ObserverC implements Observer {

public void takeAction() {

System.out.println("I am Observer C ,I just look ,and do nothing");

}

}

public class Main {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

ObserverA a = new ObserverA();

ObserverB b = new ObserverB();

ObserverC c = new ObserverC();

ObservedObject oo = new ObservedObject();

oo.addObserver(a);

oo.addObserver(b);

oo.addObserver(c);

for (int i = 0; i 5; ++i) {

oo.addObserver(new Observer() {

public void takeAction() {

System.out.println("我是山寨觀察者"+"，誰敢攔我");

}

});

}

//sometime oo changed ,so it calls update and informs all observer

oo.update();

}

}

觀察者模式的精髓在于注冊一個觀察者觀測可能隨時變化的對象，對象變化時就會自動通知觀察者，

這樣在被觀測對象影響范圍廣，可能引起多個類的行為改變時很好用，因為無需修改被觀測對象的代碼就可以增加被觀測對象影響的類，這樣的設計模式使得代碼易于管理和維護，并且減少了出錯幾率

至于異步機制實際是個噱頭，可以有觀測對象來實現異步，也可以有觀察者自身實現，這個程序實際是觀測對象實現了異步機制，方法是在觀察者類外包裝了一層invoker類

java 異步調用方法

1. 使用wait和notify方法

這個方法其實是利用了鎖機制，直接貼代碼:

public class Demo1 extends BaseDemo{ private final Object lock = new Object(); @Override public void callback(long response) { System.out.println("得到結果"); System.out.println(response); System.out.println("調用結束"); synchronized (lock) { lock.notifyAll(); } } public static void main(String[] args) { Demo1 demo1 = new Demo1(); demo1.call(); synchronized (demo1.lock){ try { demo1.lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("主線程內容"); } }

可以看到在發起調用后，主線程利用wait進行阻塞，等待回調中調用notify或者notifyAll方法來進行喚醒。注意，和大家認知的一樣，這里wait和notify都是需要先獲得對象的鎖的。在主線程中最后我們打印了一個內容，這也是用來驗證實驗結果的，如果沒有wait和notify，主線程內容會緊隨調用內容立刻打印;而像我們上面的代碼，主線程內容會一直等待回調函數調用結束才會進行打印。

沒有使用同步操作的情況下，打印結果:發起調用 調用返回 主線程內容 得到結果 1 調用結束

而使用了同步操作后:

發起調用 調用返回 得到結果 9 調用結束 主線程內容2. 使用條件鎖

和方法一的原理類似:

public class Demo2 extends BaseDemo { private final Lock lock = new ReentrantLock(); private final Condition con = lock.newCondition(); @Override public void callback(long response) { System.out.println("得到結果"); System.out.println(response); System.out.println("調用結束"); lock.lock(); try { con.signal(); }finally { lock.unlock(); } } public static void main(String[] args) { Demo2 demo2 = new Demo2(); demo2.call(); demo2.lock.lock(); try { demo2.con.await(); } catch (InterruptedException e) { e.printStackTrace(); }finally { demo2.lock.unlock(); } System.out.println("主線程內容"); } }

基本上和方法一沒什么區別，只是這里使用了條件鎖，兩者的鎖機制有所不同。

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異步代碼塊 java 異步編程
瀏覽路徑：http://www.yijiale78.com/article24/ddjgsce.html

成都網站建設公司_創新互聯，為您提供云服務器、用戶體驗、網站設計、虛擬主機、網站營銷、網站內鏈

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯