ab3e566699
Summary: 1. Move disOwnNativeHandle() function from RocksDB to RocksObject to allow other RocksObject to use disOwnNativeHandle() when its ownership of native handle has been transferred. 2. RocksObject now has an abstract implementation of dispose(), which does the following two things. First, it checks whether both isOwningNativeHandle() and isInitialized() return true. If so, it will call the protected abstract function dispose0(), which all the subclasses of RocksObject should implement. Second, it sets nativeHandle_ = 0. This redesign ensure all subclasses of RocksObject have the same dispose behavior. 3. All subclasses of RocksObject now should implement dispose0() instead of dispose(), and dispose0() will be called only when isInitialized() returns true. Test Plan: make rocksdbjava make jtest Reviewers: dhruba, sdong, ankgup87, rsumbaly, swapnilghike, zzbennett, haobo Reviewed By: haobo Subscribers: leveldb Differential Revision: https://reviews.facebook.net/D18801
73 lines
2.2 KiB
Java
73 lines
2.2 KiB
Java
// Copyright (c) 2014, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under the BSD-style license found in the
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
|
|
package org.rocksdb;
|
|
|
|
/**
|
|
* RocksObject is the base-class of all RocksDB related class that has
|
|
* a pointer to some c++ rocksdb object. Although RocksObject
|
|
* will release its c++ resource on its finalize() once it has been
|
|
* garbage-collected, it is suggested to call dispose() manually to
|
|
* release its c++ resource once an instance of RocksObject is no
|
|
* longer used.
|
|
*/
|
|
public abstract class RocksObject {
|
|
protected RocksObject() {
|
|
nativeHandle_ = 0;
|
|
owningHandle_ = true;
|
|
}
|
|
|
|
/**
|
|
* Release the c++ object pointed by the native handle.
|
|
*
|
|
* Note that once an instance of RocksObject has been disposed,
|
|
* calling its function will lead undefined behavior.
|
|
*/
|
|
public final synchronized void dispose() {
|
|
if (isOwningNativeHandle() && isInitialized()) {
|
|
disposeInternal();
|
|
}
|
|
nativeHandle_ = 0;
|
|
disOwnNativeHandle();
|
|
}
|
|
|
|
/**
|
|
* The helper function of dispose() which all subclasses of RocksObject
|
|
* must implement to release their associated C++ resource.
|
|
*/
|
|
protected abstract void disposeInternal();
|
|
|
|
/**
|
|
* Revoke ownership of the native object.
|
|
*
|
|
* This will prevent the object from attempting to delete the underlying
|
|
* native object in its finalizer. This must be used when another object
|
|
* takes over ownership of the native object or both will attempt to delete
|
|
* the underlying object when garbage collected.
|
|
*
|
|
* When disOwnNativeHandle is called, dispose() will simply set nativeHandle_
|
|
* to 0 without releasing its associated C++ resource. As a result,
|
|
* incorrectly use this function may cause memory leak.
|
|
*/
|
|
protected void disOwnNativeHandle() {
|
|
owningHandle_ = false;
|
|
}
|
|
|
|
protected boolean isOwningNativeHandle() {
|
|
return owningHandle_;
|
|
}
|
|
|
|
protected boolean isInitialized() {
|
|
return (nativeHandle_ != 0);
|
|
}
|
|
|
|
@Override protected void finalize() {
|
|
dispose();
|
|
}
|
|
|
|
protected long nativeHandle_;
|
|
private boolean owningHandle_;
|
|
}
|