Some sun.misc internal APIs are deprectaed in JDK 9 and will be encapsulated or removed in a future release.
Refine search
private Cleaner createCleaner(Entry<T> entry) { return Cleaner.create(entry, new Runnable() { @Override public void run() { closeFromCleaner(); } }); }
public void freeAndClose() { cleaner.clean(); }
import java.util.*; import com.everis.csv.Cleaner; public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException { Cleaner c = new Cleaner(); c.clean(); // The rest of it is for making it work // You will also need to make a Generate Rows step that inputs a row to this step. Object[] r = getRow(); if (r == null) { setOutputDone(); return false; } r = createOutputRow(r, data.outputRowMeta.size()); putRow(data.outputRowMeta, r); return true; }
/** * Creates a new cleaner. * * @param thunk * The cleanup code to be run when the cleaner is invoked. The * cleanup code is run directly from the reference-handler thread, * so it should be as simple and straightforward as possible. * * @return The new cleaner */ public static Cleaner create(Object ob, Runnable thunk) { if (thunk == null) return null; return add(new Cleaner(ob, thunk)); }
public static void unmap(MappedByteBuffer buffer) { sun.misc.Cleaner cleaner = ((DirectBuffer) buffer).cleaner(); cleaner.clean(); }
public static void clean(ByteBuffer bb) { if(bb == null) return; Cleaner cleaner = ((DirectBuffer) bb).cleaner(); if (cleaner != null) cleaner.clean(); }
public ReferenceCountingResourceHolder(final T object, final Closeable closer) { this.object = object; this.closer = closer; this.cleaner = Cleaner.create(this, new CloserRunnable(object, closer, refCount)); }
public void freeAndClose() { cleaner.clean(); }
private CountingHolder(final MemcachedClientIF clientIF) { this.clientIF = clientIF; cleaner = Cleaner.create(this, new ClientLeakNotifier(count, clientIF)); } }
@Override void disposeCache(CacheHandler cacheHandler) { MapDbCacheDisposerAndCleaner disposerAndCleaner = (MapDbCacheDisposerAndCleaner) cacheHandler.id; disposerAndCleaner.cacheDisposer.disposeManually(); // This clean() call effectively just removes the Cleaner from the internal linked list of all cleaners. // The thunk.run() will be a no-op because cacheDisposer.disposed is already set to true. disposerAndCleaner.cleaner.clean(); }
protected void init(String file, long length, boolean clearFile) throws Exception { File f = new File(file); if ( f.exists() && clearFile ) { f.delete(); } this.file = f; if ( f.exists() ) { length = f.length(); } RandomAccessFile raf = new RandomAccessFile(f, "rw"); raf.setLength(length); // FIXME: see stackoverflow. does not work always FileChannel fileChannel = raf.getChannel(); this.fileChannel = raf.getChannel(); this.baseAdress = map0(fileChannel, imodeFor(FileChannel.MapMode.READ_WRITE), 0L, length); this.length = length; this.cleaner = Cleaner.create(this, new Unmapper(baseAdress, length, fileChannel)); }
@Override public void deallocate(MemoryBuffer buffer) { LlapAllocatorBuffer buf = (LlapAllocatorBuffer)buffer; ByteBuffer bb = buf.byteBuffer; buf.byteBuffer = null; if (!bb.isDirect()) return; Field field = cleanerField; if (field == null) return; try { ((Cleaner)field.get(bb)).clean(); } catch (Throwable t) { LlapIoImpl.LOG.warn("Error using DirectByteBuffer cleaner; stopping its use", t); cleanerField = null; } }
private ObjectResourceHolder makeObjectWithHandler() { T object = generator.get(); ObjectId objectId = new ObjectId(); ObjectLeakNotifier notifier = new ObjectLeakNotifier(this); // Using objectId as referent for Cleaner, because if the object itself (e. g. ByteBuffer) is leaked after taken // from the pool, and the ResourceHolder is not closed, Cleaner won't notify about the leak. return new ObjectResourceHolder(object, objectId, Cleaner.create(objectId, notifier), notifier); }
@Override public void close() { if (!doClose(true)) { log.error("Cache for %s has already been closed", this); } // This Cleaner.clean() call effectively just removes the Cleaner from the internal linked list of all cleaners. // It will delegate to closeFromCleaner() which will be a no-op because cacheStateHolder is already set to // ENTRY_CLOSED. entryCleaner.clean(); }