Java 是否隐式定义了对类中使用的对象的引用？

Question

看了书，上网查了一下Java中的引用类型，我还是有一些疑惑（或者可能是我对这个概念的理解错误）。
如果有人消除我的疑虑，那对我来说会有很大的帮助。

让我举一个包含类变量、实例变量和局部变量的类的例子。

public class Test {
  public static ArrayList<String> listCommon = new ArrayList<String>();
  private HashMap<String, String> mapInstance;

  public Test() {
    mapInstance = new HashMap<String, String>();
  }

  public void doSomething(String key) {
    ArrayList<String> local = new ArrayList<String>();
    if(key != null){
      local.add(mapInstance.get(key));
    }

    System.out.println("Value is added in instance Map: ", mapInstance.get(key));
  }
}

我的问题是；
1. listCommon（静态变量）和mapInstance（实例变量）是对垃圾收集器的强引用吗？
2. 变量local（在方法中定义和使用）是弱引用吗？
3. 幻像参考和软参考是如何出现的？
4、OR以上3个概念无效；是否意味着只有显式使用 java.lang.ref 包中定义的类型时，Java 才会定义引用？

任何帮助对我来说都是很大的。

Answer 1

1. listCommon（静态变量）和mapInstance（实例变量）是对垃圾收集器的强引用吗？

是的，它们是强有力的参考。

1. 局部变量（在方法中定义和使用）是弱引用吗？

不，它是一个局部变量，所以它是一个变量，所以它仍然是一个强引用。

1. 幻像参考和软参考是如何出现的？

如果你使用它们。如果您不使用它们，则无需担心它们。它们实际上是用于编写各种类型的缓存。

1. 或者以上3个概念无效；意味着 Java 仅当您显式使用中定义的类型时才定义引用
   java.lang.ref 包？

参考变量总是很强的。其他类型仅在您明确使用它们时才会出现。

Answer 2

回答问题：

1. 是的，它们具有很强的参考性。弱引用是使用 弱引用 定义的目的。

2. 否，原因为 1)。

3. Phantom Reference 没有不适用于您的示例。默认情况下，所有实例都是强引用。

4. 是的，您可以使用java.lang.ref包指定弱/幻像引用。默认情况下，使用强引用。

注意：维基百科对弱引用的解释可能会有用。

Answer 3

阅读这篇有关变量引用的博客文章。

** 更新 **

原子引用是以原子方式访问的方式引用的对象；这意味着没有竞争条件访问它。例如：

class RaceTest {
   static private int count = 0;
   static public void main(String...args) {
      Thread t1 = new Thread(new Runnable() {
         public void run() {
             for (int i=0; i<1000000; i++) {
                 count++;
             }
      });
      Thread t2 = new Thread(new Runnable() {
         public void run() {
             for (int i=0; i<1000000; i++) {
                 count--;
             }
         }
      });

      t1.start();
      t2.start();

      t1.join();
      t2.join();

      System.out.println("Final count (should be 0) = " + count);
   }
}

将生成两个线程，1）将增加 count 并 2）将减少它。现在，两个线程将并行运行，程序将等待直到两个线程终止（在join点）。一个常见的想法是，由于两个线程具有相同的循环（将循环相同的时间），因此每个线程都会“取消”彼此的操作，因此 count 应该为 0，但这不是案件。为什么？因为，例如，t1可能想要增加变量，这样的操作不是原子的，而是更多的顺序：get，inc，<代码>设置。因此，在某些情况下，即使在进行第二个操作 inc 之前，t2 也会访问变量并 dec 变量，因此 < code>t1 实际上会有 +2 变量。反之亦然，以无限期的方式。 （每次运行代码都会产生不同的值。）

现在，将 int 替换为 AtomicInteger 并使用 incrementAndGet() 或 decrementAndGet () 将通过将 get、inc、set 渲染为单个操作来解决该问题，并消除其中的竞争条件代码。