相关疑难解决方法(0)

我们什么时候使用AtomicReference？

是否需要在所有多线程程序中创建对象？

提供一个应该使用AtomicReference的简单示例.

我们都知道,为了调用Object.wait(),这个调用必须放在synchronized块中,否则IllegalMonitorStateException抛出一个.但是这个限制的原因是什么？我知道wait()释放监视器,但为什么我们需要通过使特定块同步显式获取监视器,然后通过调用释放监视器wait()？

如果可以wait()在同步块之外调用,保留它的语义 - 暂停调用程序线程,可能造成的损害是什么？

我读了一些java代码,发现了这些函数:

synchronized void setConnected(boolean connected){
   this.connected = connected;
}

synchronized boolean isConnected(){
   return connected;
}

我想知道这里的同步是否有意义,或者只是作者不理解synchronized关键字的必要性？

我想在这里同步是没用的.还是我弄错了？

我有一个对象负责将JTable状态持久化到磁盘.它保存/加载可见列,它们的大小,位置等.下面是类定义中的一些有趣的部分.

class TableSaver {
    Timer timer = new Timer(true);

    TableSaver() {
        timer.schedule(new TableSaverTimerTask(), 15000, SAVE_STATE_PERIOD);
    }

    synchronized TableColumns load(PersistentTable table) {
        String xml = loadFile(table.getTableKey());
        // parse XML, return
    }

    synchronized void save(String key, TableColumns value) {
        try {
            // Some preparations
            writeFile(app.getTableConfigFileName(key), xml);
        } catch (Exception e) {
            // ... handle
        }
    }

    private class TableSaverTimerTask extends TimerTask {
        @Override
        public void run() {
            synchronized (TableSaver.this) {
                Iterator<PersistentTable> iterator = queue.iterator();
                while (iterator.hasNext()) {
                    PersistentTable table = …

以下代码中会发生什么？同步是否有效？这是一个面试问题.

class T
{
    public static void main(String args[])
    {
        Object myObject = new Object();
        synchronized (myObject)
        {
            myObject = new Object();
        } // end sync
    }
}

private static Integer balance=0;

public static void deposit(final int amt) {
    Thread t = new Thread(new Runnable() {
        public void run() {
            synchronized(balance) {
                System.out.println("Balance at start is: "+balance);        
                balance+=amt;
                System.out.println("deposited " + Integer.toString(amt) + " to funds. Now at " + Integer.toString(balance));
            }
        }
    });
}

当我运行上面的简单存款函数时,我希望两个线程不应该在synchronized块中同时进入.但是操作顺序如下:

1. Depo100
2. Depo200
3. Depo700

输出如下:

------------------
Balance at start is: 0
deposited 100 to funds. Now at 100
Balance at start is: 100
Balance at start is: 100
deposited 700 to funds. Now …

考虑以下代码段:

 Object bar1  = new ... ; 
 Object bar2 = new ... ; 


 Object foo = (either bar1 or bar2) ; 

现在,foo在程序的不同时间可以是bar1或bar2.我只想检查synchronized(foo)是否会锁定相应的bar1或bar2.这似乎是最有可能的情况,因为对象不是用Java复制的.它是否正确？

当一个对象需要同步时,IDE会抱怨它是否设置为非final(因为它的引用不是持久的):

private static Object myTable;
....

synchronized(myTable){          //IDE complains!
     //access myTable here...
}

众所周知,如果持有锁的线程改变了非最终对象的引用,IDE会抱怨阻止另一个线程进入受保护的块.

但是同步对象的引用是否也可以由另一个线程B更改,而线程A保持同一对象的锁定？

我有一个课程如下

public MyClass{

Boolean flag = false;

    public Boolean getflag(){
       synchronized(flag){
          //BLOCK 1
          return flag;
       }
    }

    public Boolean setflag(){
       synchronized(flag){
           //BLOCK 2
           this.flag = flag;
       }
    }
}

两种方法都在对象标志上同步.现在我怀疑是两个不同的线程可以同时执行同步块(1和2).可能出现以下情况吗？1)线程1是设置标志值,线程2是否同时获取其值？