Question

我将高速缓存作为服务中的成员变量，并且正在创建一种通过JMX MBean公开它的方法，以便可以在运行时使用新的高速缓存到期时间拆除并重新创建vogon高速缓存：< / p>

public class CachedVogonService implements CachedVogonServiceMBean {

    private LoadingCache<String, Vogon> cache;
    private long expiryInSeconds;
    private VogonService service;

    public CachedVogonService(VogonService newService,
                                long newExpiryInSeconds) {
        this.expiryInSeconds = newExpiryInSeconds;
        this.service = newService;
        this.cache = createCache(newService, newExpiryInSeconds);
    }

    private LoadingCache<String, Vogon> createCache(
            VogonService newService,
            long expiryInSeconds) {
        return CacheBuilder.newBuilder()
                .refreshAfterWrite(expiryInSeconds, TimeUnit.SECONDS)
                .build(new VogonCacheLoader(
                        Executors.newCachedThreadPool(), newService));
    }

    /**
     * This is the method I am exposing in JMX
     */    
    @Override
    public void setExpiryInSeconds(long newExpiryInSeconds) {
        this.expiryInSeconds = newExpiryInSeconds;
        synchronized (this.cache) {
            this.cache = createCache(service, expiryInSeconds);
        }
    }

我担心我的锁定技术将导致JVM保留对旧缓存的引用，并阻止对其进行垃圾回收。

如果我的服务对象丢失了对同步块内旧缓存的引用，那么当执行退出该块时，是否可以将旧缓存对象仍标记为锁定-使其无法进行垃圾回收？

Answer 1

通过查看在类似情况下生成的字节码，我们可以看到锁定字段的对象地址被复制并用于获取和释放锁定。因此，原始锁定对象用于锁定。

在同步块内使用新对象更改锁定字段之后，另一个线程可以获取新对象上的锁，并可以进入同步代码块。像这样使用同步，不提供线程之间的同步。您应该使用另一个对象进行锁定。（例如最终的对象cacheLock = new Object（））

仅出于提供信息的目的，这种用法不会阻止垃圾收集。由于此处提到的对象地址在此方法的堆栈框架内部，因此一旦该方法完成执行，堆栈框架将被破坏，并且将不保留对旧对象的引用。（但不要像这样使用同步。）

您可以检查JVM指令集here

public class SyncTest {

    private Long value;

    public static void main(String[] args) {
        new SyncTest().testLock();
    }

    public SyncTest() {
        value = new Long(1);
    }

    private void testLock() {
        synchronized (this.value) {
            this.value = new Long(15);
        }
    }
}

  private void testLock();
     0  aload_0 [this]
     1  getfield t1.SyncTest.value : java.lang.Long [27] // push value field to operand stack
     4  dup // duplicate value field push it to operand stack
     5  astore_1 // store the top of the operand stack at [1] of local variable array (which is the duplicated value field)
     6  monitorenter // aquire lock on top of the operand stack 
     7  aload_0 [this]
     8  new java.lang.Long [22]
    11  dup
    12  ldc2_w <Long 15> [31]
    15  invokespecial java.lang.Long(long) [24]
    18  putfield t1.SyncTest.value : java.lang.Long [27]
    21  aload_1 // load the [1] of local variable array to the operand stack (which is the duplicated value field previously stored)
    22  monitorexit // release the lock on top of the operand stack
    23  goto 29
    26  aload_1
    27  monitorexit
    .....

覆盖同步锁中使用的变量是否可以防止其垃圾回收？

1 个答案: