Java 为什么NetBeans在这里显示关于空指针取消引用的警告？

我有以下代码：

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class NullDereference {

    private static final ConcurrentMap<Integer, Object> MAP = new ConcurrentHashMap<>();

    public static void main(String[] args) {
        Object object = getObject(1);

        if (object == null) {
            Lock lock = new ReentrantLock();
            lock.lock();
            try {
                lock.newCondition().await(1, TimeUnit.SECONDS);

                object = new Object();
                object = addObject(object); // [3]
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            } finally {        // [1]
                lock.unlock(); // [1]
            }
        }

        System.out.println("class: " + object.getClass()); // [2]
    }

    private static Object getObject(int hashCode) {
        return MAP.get(hashCode);
    }

    private static Object addObject(Object newObject) {
        Object oldObject = MAP.putIfAbsent(newObject.hashCode(), newObject);
        if (oldObject != null) {
            return oldObject;
        }

        return newObject;
    }
}

import java.util.concurrent.ConcurrentHashMap；
导入java.util.concurrent.ConcurrentMap；
导入java.util.concurrent.TimeUnit；
导入java.util.concurrent.locks.Lock；
导入java.util.concurrent.locks.ReentrantLock；
公共类NullDereference{
私有静态最终ConcurrentMap=新ConcurrentHashMap（）；
公共静态void main（字符串[]args）{
Object Object=getObject（1）；
if（object==null）{
Lock Lock=新的可重入锁（）；
lock.lock（）；
试一试{
lock.newCondition（）.await（1，TimeUnit.SECONDS）；
对象=新对象（）；
object=addObject（object）；//[3]
}捕获（中断异常例外）{
抛出新的运行时异常（ex）；
}最后{/[1]
lock.unlock（）；//[1]
}
}
System.out.println（“类：“+object.getClass（））；//[2]
}
私有静态对象getObject（int hashCode）{
返回MAP.get（hashCode）；
}
私有静态对象addObject（对象newObject）{
Object oldObject=MAP.putIfAbsent（newObject.hashCode（），newObject）；
if（oldObject！=null）{
返回旧对象；
}
返回newObject；
}
}

NetBeans在第[2]行显示关于“取消引用可能的空指针”的警告。我不知道为什么。我认为这是因为第[3]行，但当我注释掉第[3]行时，警告仍然存在。当我在第[2]行之前显式检查null值，或者注释掉整个

finally

语句（由[1]注释的行）时，警告消失

我分析了代码，认为这是一个误报。我说得对吗

---

我不想对空指针进行额外检查。此代码可能有什么问题？我可以在没有警告的情况下更改代码吗？

我可以复制它。Short：你说得对，它看起来像是NetBeans bug。Eclipse和IDEA在此不显示警告

Long：发出“可能的null解引用”警告并不是非常简单的静态分析，因为它需要仔细遍历所有可能的控制流路径（实际上我正在编写类似的分析器，所以我知道这有多困难）。拥有

finally

使事情变得更加困难，因为finally部分在每个代码路径之后执行，然后将控件返回到原始代码。适当的控制流图必须对finally块进行多个复制，仅添加几个传入和传出边是不够的。我可以推测NetBeans在这一部分做得不正确

以下是不正确的控制流程图草图：

[ try { lock.newCondition().await(...) ...} ]
         /          |          \
        /           |           \
       /            |            \
Successful  InterruptedException  other exception
Execution           |               /
     \              |              /
      \             |             /
       \            |            /
     [ finally {  lock.unlock;  }  ]
       /            |            \
      /             |             \
     /              |              \
    |               |               |
[System.out]    [throw RuntimeEx] [throw the original exception]

请注意，沿着此图的边缘，您可以在

中断异常

或其他一些异常之后访问最终的

System.out

语句。正确的图形必须复制三个最终块：

[ try { lock.newCondition().await(...) ...} ]
         /          |          \
        /           |           \
       /            |            \
Successful  InterruptedException  other exception
Execution           |                |
    |               |                |
[finally_copy1] [finally_copy2]   [finally_copy3]
    |               |                |
    |               |                |
[System.out]    [throw RuntimeEx] [throw the original exception]

---

这样，只有在

对象

确实被赋值时，才能成功地执行

try

后，才能到达

系统.out

语句。

因为没有强语句，它相信编译器已初始化

对象

，并且从不给出null