How to use

msync

method

in

libcore.io.Os

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); }
public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}

/**
 * Flushes changes made to the in-memory buffer back to the mapped file.
 * Unless you call this, changes may not be written back until the finalizer
 * runs. This method waits for the write to complete before returning.
 *
 * @return this buffer.
 */
public final MappedByteBuffer force() {
 checkIsMapped();
 if (mapMode == MapMode.READ_WRITE) {
  try {
   Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC);
  } catch (ErrnoException errnoException) {
   // The RI doesn't throw, presumably on the assumption that you can't get into
   // a state where msync(2) could return an error.
   throw new AssertionError(errnoException);
  }
 }
 return this;
}