Java線程：同步塊

我需要一些幫助，以確保我理解同步塊。假設下面的例子：Java線程：同步塊

public class ThreadStarter { 
    public static void main(String[] args) { 

     Queue queueObject = new Queue(); 

     ThreadA thread1 = new ThreadA(queueObject); 
     ThreadA thread2 = new ThreadA(queueObject); 

     ThreadB thread3 = new ThreadB(queueObject); 
     ThreadB thread4 = new ThreadB(queueObject); 

     thread1.start(); 
     thread2.start(); 

    } 
} 

public class Queue { 

    Object[] the theQueue; 

    public Queue(int size){ 
     theQueue = new Object[size]; 
    } 

    public submitObject(Object o){ 
     /* add Object to the queue */ 
    } 

    public deleteObject(int objectId){ 
     /*delete Object from the queue */ 
    } 
} 

public class ThreadA extends Thread { 

    private Queue queue; 

    public ThreadA(Queue queue){ 
     this.queue = queue; 
    } 

    public void run() { 
     while(!isInterrupted()){ 
      synchronized(queue) { 
       Object o = new Object 
       queue.submitObject(o); 
       /* do some other stuff */ 
     } 

     try { 
      sleep((int)(Math.random()*1000)); 
     } catch (interruptedException) { 
      Thread.currentThread().interrupt; 
     } 

      synchronized(queue) { 
       /* do some other stuff on the queue */ 
      } 
     } 
    } 
} 

public class ThreadB extends Thread { 

    private Queue queue; 

    public ThreadB(Queue queue){ 
     this.queue = queue; 
    } 

    public void run() { 
     while(!isInterrupted()){ 
      synchronized(queue) { 
       queue.deleteObject(o); 
       /* do some other stuff */ 
     } 

     try { 
      sleep(1000); 
     } catch (interruptedException) { 
      Thread.currentThread().interrupt; 
     } 
    } 
} 
}

我的問題是，它足以同步ThreadA中的整個隊列對象提交的目標隊列類，是在安全方面？我在ThreadB中做了同樣的操作，從隊列中刪除一個對象。或者，我還必須同步Queue類中的submitObject（）和deleteObject（）方法嗎？

在我的理解中，如果我像上面顯示的那樣鎖定了線程中的整個隊列類，我應該保持安全 - 對吧？

greetZ並提前致謝。

來源

2012-03-12 Bins Ich

所有你需要做的是確保沒有兩個線程不能同時進入submitObject & deleteObjecct。要做到這一點，只需聲明這些方法是同步的。在這種情況下，類之間共享的隊列對象將阻止2個線程在同步的塊上進行。

如果你願意，而且有某種閉鎖機制，如：

「如果一個線程想刪除一個對象，它必須等待，如果有沒有這樣的一個對象隊列。」

，那麼你需要做的不僅僅是同步這種方式更多：這兩種方法應該還是同步的，但進入DeleteObject的線程應該使用this.wait由隊列停止，直到有一個對象變爲可用：

public synchronized deleteObject() { 
    while(isEmpty()) { 
    try { 
     wait(); 
    } catch(Exception ex) { 
     ex.printStackTrace(); 
    }//catch 
    }//while 

    //actually do delete object. 
    ... 
}//met

然後submitObject應該做通知等待狀態線程：

public synchronized submitObject() { 
    //do put object 
    ... 
    notifyAll(); 
}//met

，你也可以穿越的角色和在兩種方法中添加一些代碼，在立場，允許提交者在隊列已滿時被阻止，並在隊列中剩餘一些空間時通知。

來源

2012-03-12 19:48:15 Snicolas

我會在submitObject和deleteObject方法隊列對象上同步，這應該是足夠的，這意味着：

public submitObject(Object o){ 
    synchronized (theQueue) { 
     ... 
    } 
} 

public deleteObject(int objectId){ 
    synchronized (theQueue) { 
     ... 
    } 
}

來源

2012-03-12 19:40:21 suat

你要做的就是相當於同步方法（public synchronized method()與this同步這是您的queue局部變量），只是必須記住每次使用隊列時都需要執行此操作。同步提交和刪除方法會更安全.... 它也會從同步塊中刪除Object o = new Object()。

來源

2012-03-12 19:40:43 assylias

+1：你封裝同步的越多，它越容易和安全。 – 2012-03-12 19:43:39

它在功能上並不等同於「隊列」的方法。如果他這樣做了，那麼在每個'synchronized'部分找到的'/ *'還有一些其他的東西* /'不會處於關鍵部分並且可以並行運行。根據代碼的內容，這對同步也很重要。這與同步列表很相似：如果你想以原子方式執行多個操作（例如遍歷它），你仍然需要在列表上進行外部同步。 – 2012-03-12 20:00:58

@MaxPeters完全同意。 – assylias 2012-03-12 20:02:12

Java線程：同步塊

回答

相關問題