Let's take a look at what 'weak' references are in Java?

Java Basic Tutorial Column Introduction Java "Weak" Quote

Recommended (Free): java basic tutorial

When an object obj is created in Java, it is placed on the heap. When the GC runs and finds that there is no reference pointing to obj, the heap memory space of the obj object will be reclaimed.

In other words, for an object to be recycled, it must meet two conditions:

(1) There is no reference pointing to it

(2) GC is run.

In actual development, we can ensure that this object is recycled the next time the GC runs by emptying all referece pointing to an object, similar to the following:

Object c = new Car();    
c=null;

However, this Doing this is very cumbersome and goes against the principle of automatic GC recycling. For simple cases, manual setting is not required by programmers, because in Java, for simple objects, when the method that calls it is executed, the reference pointing to it will be popped from the stack, so it can It is recycled during the next GC execution.

However, there are special exceptions. When using cache, since the objects in the cache are exactly what the program needs to run, as long as the program is running, the references in the cache will not be GC (or, in other words, in the cache The references have the same life cycle as the main program). As there are more and more references in the cache, more and more objects cannot be recycled by the GC and cannot be automatically recycled. When these objects need to be recycled, the task of recycling these objects can only be left to the programmer. However, this goes against the essence of GC (automatic recycling of objects that can be recycled).

So, weak reference was introduced in java.

Object c = new Car(); //只要c还指向car object, car object就不会被回收 -->（强引用）

When an object is only pointed to by a weak reference without any other strong reference, if the GC runs, the object will be recycled.

The following is an example from the Internet. First define an entity class:

public class Car {
    private double     price;
    private String    color;

    public Car(double price, String color)
    {
        this.price = price;
        this.color = color;
    }

    public double getPrice()
    {
        return price;
    }

    public String getColor()
    {
        return color;
    }

    public String toString()
    {
        return "This car is a " + this.color + " car, costs $" + price;
    }
}

Generally when using WeakReference, a class will be defined to inherit from WeakReference, and some other attributes will be defined in this class. No other attributes are defined here:

public class WeakReferenceCar extends WeakReference<Car>
{
    public WeakReferenceCar(Car car)
    {
        super(car);
    }
}

The main function is called. Of course, in order to see the effect of GC more clearly, set the virtual machine parameter "-XX: PrintGCDetails":

public static void main(String[] args)
{
    Car car = new Car(2000.0, "red");
    WeakReferenceCar wrc = new WeakReferenceCar(car);
    wrc.setStr("111");
    int i = 0;
    while (true)
    {
        if (wrc.get() != null)
        {
            i++;
            System.out.println("WeakReferenceCar's Car is alive for " + i + ", loop - " + wrc);
        }
        else
        {
            System.out.println("WeakReferenceCar's Car has bean collected");
            break;
        }
    }
}

The last is the running result

WeakReferenceCar's Car is alive for 68450, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68451, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68452, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car is alive for 68453, loop - interview.WeakReferenceCar@776ec8df
[GC (Allocation Failure) [PSYoungGen: 34304K->1000K(38400K)] 34320K->1016K(125952K), 0.0015129 secs] [Times: user=0.02 sys=0.02, real=0.00 secs] 
WeakReferenceCar's Car is alive for 68454, loop - interview.WeakReferenceCar@776ec8df
WeakReferenceCar's Car has bean collected
Heap
PSYoungGen      total 38400K, used 1986K [0x00000000d5e00000, 0x00000000da900000, 0x0000000100000000)
eden space 33280K, 2% used [0x00000000d5e00000,0x00000000d5ef6b70,0x00000000d7e80000)
from space 5120K, 19% used [0x00000000d7e80000,0x00000000d7f7a020,0x00000000d8380000)
to   space 5120K, 0% used [0x00000000da400000,0x00000000da400000,0x00000000da900000)
ParOldGen       total 87552K, used 16K [0x0000000081a00000, 0x0000000086f80000, 0x00000000d5e00000)
object space 87552K, 0% used [0x0000000081a00000,0x0000000081a04000,0x0000000086f80000)
Metaspace       used 3547K, capacity 4564K, committed 4864K, reserved 1056768K
class space    used 381K, capacity 388K, committed 512K, reserved 1048576K

It can be seen that after the 68454 cycle, the object Car associated with the WeakReferenceCar is recycled. Note that the object car associated with the weak reference is recycled, not the weak reference itself wrc.

One of the characteristics of WeakReference is that it is uncertain when it will be recycled, because this is determined by the uncertainty of GC operation. Therefore, generally objects referenced by weak references are valuable and cached. It is also an object that is easy to be re-constructed and consumes a lot of memory.

After the object pointed to by the weak reference is recycled, the weak reference itself is actually useless. Java provides a ReferenceQueue to save these A reference that points to an object that has been recycled. The usage is to pass a ReferenceQueue object as a parameter into the constructor when defining WeakReference.

The above is the detailed content of Let's take a look at what 'weak' references are in Java?. For more information, please follow other related articles on the PHP Chinese website!