@Test public void testLockNegative() throws IOException { FileChannel channel = channel(regularFile(0), READ, WRITE); try { channel.lock(-1, 10, true); fail(); } catch (IllegalArgumentException expected) { } try { channel.lock(0, -1, true); fail(); } catch (IllegalArgumentException expected) { } try { channel.tryLock(-1, 10, true); fail(); } catch (IllegalArgumentException expected) { } try { channel.tryLock(0, -1, true); fail(); } catch (IllegalArgumentException expected) { } }
/** @tests java.nio.channels.FileLock#release() */ public void test_release() throws Exception { File file = File.createTempFile("test", "tmp"); file.deleteOnExit(); FileOutputStream fout = new FileOutputStream(file); FileChannel fileChannel = fout.getChannel(); FileLock fileLock = fileChannel.lock(); fileChannel.close(); try { fileLock.release(); fail("should throw ClosedChannelException"); } catch (ClosedChannelException e) { // expected } // release after release fout = new FileOutputStream(file); fileChannel = fout.getChannel(); fileLock = fileChannel.lock(); fileLock.release(); fileChannel.close(); try { fileLock.release(); fail("should throw ClosedChannelException"); } catch (ClosedChannelException e) { // expected } }
/** * Copy the content of the source file to the destination file * * @param aSrcFile Source file. May not be <code>null</code>. * @param aDestFile Destination file. May not be <code>null</code>. * @return {@link ESuccess} */ @Nonnull private static ESuccess _copyFile(@Nonnull final File aSrcFile, @Nonnull final File aDestFile) { final FileChannel aSrcChannel = FileUtils.getFileReadChannel(aSrcFile); if (aSrcChannel == null) return ESuccess.FAILURE; try { final FileChannel aDstChannel = FileUtils.getFileWriteChannel(aDestFile, EAppend.TRUNCATE); if (aDstChannel == null) return ESuccess.FAILURE; try { FileLock aSrcLock = null; FileLock aDestLock = null; try { final long nBytesToRead = aSrcChannel.size(); // Shared read lock and exclusive write lock aSrcLock = aSrcChannel.lock(0, nBytesToRead, true); aDestLock = aDstChannel.lock(); // Main copying - the loop version is much quicker than then // transferTo with full size! long nBytesWritten = 0; final long nChunkSize = 1 * CGlobal.BYTES_PER_MEGABYTE; while (nBytesWritten < nBytesToRead) nBytesWritten += aSrcChannel.transferTo(nBytesWritten, nChunkSize, aDstChannel); if (nBytesToRead != nBytesWritten) { s_aLogger.error( "Failed to copy file. Meant to read " + nBytesToRead + " bytes but wrote " + nBytesWritten); return ESuccess.FAILURE; } return ESuccess.SUCCESS; } catch (final IOException ex) { throw new IllegalStateException( "Failed to copy from " + aSrcFile + " to " + aDestFile, ex); } finally { // Unlock ChannelUtils.release(aDestLock); ChannelUtils.release(aSrcLock); } } finally { ChannelUtils.close(aDstChannel); } } finally { ChannelUtils.close(aSrcChannel); } }
/* (non-Javadoc) * @see com.ongraphdb.store.DiskSore1#start() */ public void start() throws IOException { File file = new File(dataFileName); boolean newStore = file.exists() ? false : true; RandomAccessFile dataFile = new RandomAccessFile(dataFileName, "rw"); dataFile.setLength(initialFileSize); dataChannel = dataFile.getChannel(); dataLock = dataChannel.lock(); mappedDataBuffer = dataChannel.map(MapMode.READ_WRITE, 0, dataMappedMemorySize); if (newStore) { nextPosition = NEXT_BYTES; mappedDataBuffer.putInt(nextPosition); } else { nextPosition = mappedDataBuffer.getInt(); } shutdownHookThread = new Thread() { public void run() { try { mappedDataBuffer.force(); dataLock.release(); dataChannel.close(); unmap(mappedDataBuffer); } catch (Exception e) { e.printStackTrace(); } } }; Runtime.getRuntime().addShutdownHook(shutdownHookThread); }
private boolean lock(int flg) { try { if (fc != null) { if (flg == TRY_LOCK_FLG) { fl = fc.tryLock(); } else if (flg == LOCK_FLG) { fl = fc.lock(); } if (fl == null) { return false; } return true; } else { return false; } } catch (IOException e) { e.printStackTrace(); try { fl.release(); } catch (IOException ex) { ex.printStackTrace(); } return false; } }
/** @param args */ public static void main(String[] args) throws Exception { // 读取的 地址 File fInput = new File(Config.inputAdd); // 读取流 FileInputStream fis = new FileInputStream(fInput); // 读取 管道 FileChannel inputChannel = fis.getChannel(); // lock方式 加 共享锁 System.out.println("主线程 在 控制文件fInput - 30秒 , 当前时间子线程 - >" + new Date()); FileLock lock = inputChannel.lock(0, fInput.length(), true); System.out.println("子线程 对 fInput 加上锁了。加上的时间为: " + new Date()); if (null != lock) { System.out.println("子线程开始执行 锁里面的操作了"); } else { System.out.println("按道理说 这句话 永远 不应该被打印 的....."); } lock.release(); // 释放资源 fis.close(); inputChannel.close(); }
public void run() { try { /* Get FileLocks. */ FileChannel channel = lockFile.getChannel(); FileLock lockA = channel.lock(1, 1, false); FileLock lockC = channel.lock(3, 1, false); ReplicatedEnvironment master = getMaster(); doWork(master, dbName, 1); /* Release lock A so that read process can do reads. */ lockA.release(); /* Make sure read process get lock B before this process. */ Thread.sleep(sleepTime); /* Get lock B means read process finish reading, do updates. */ FileLock lockB = getLockWithReTry(channel, 2, 1); doWork(master, dbName, 101); /* Release lock B and lock C. */ lockB.release(); lockC.release(); } catch (Exception e) { /* Dump exceptions and exit with value 6. */ e.printStackTrace(); System.exit(7); } finally { RepTestUtils.shutdownRepEnvs(repEnvInfo); closeLockFile(lockFile); } }
/** * @param directory * @return * @throws IOException */ FileLock acquireLock(File directory) throws IOException { // Get a file channel for the file File file = new File(directory, LOCK_FILE); FileChannel channel = new RandomAccessFile(file, "rw").getChannel(); // Use the file channel to create a lock on the file. // This method blocks until it can retrieve the lock. FileLock lock = channel.lock(); // Try acquiring the lock without blocking. This method returns // null or throws an exception if the file is already locked. while (!lock.isValid()) { try { lock = channel.tryLock(); } catch (OverlappingFileLockException e) { // File is already locked in this thread or virtual machine } // wait for the other process to unlock it, should take a couple of seconds try { Thread.sleep(500); } catch (InterruptedException e) { // someone waked us earlier, no problem } } return lock; }
private static void acquireReadLock(Map<File, RandomAccessFile> lockFileMap, File indexDir) throws IOException, LockAquisitionException { final File writeLock = new File(indexDir, "delete.lock"); writeLock.createNewFile(); while (true) { synchronized (lockFileMap) { RandomAccessFile raf = lockFileMap.get(indexDir); if (raf == null) { raf = new RandomAccessFile(writeLock, "r"); lockFileMap.put(indexDir, raf); } else { throw new AlreadyOpenException(); } final FileChannel channel = raf.getChannel(); try { channel.lock(0, Long.MAX_VALUE, true); if (indexDir.exists()) { return; } lockFileMap.remove(indexDir); Closeables2.closeQuietly(raf, log); throw new ShardDeletedException(); } catch (OverlappingFileLockException e) { lockFileMap.remove(indexDir); Closeables2.closeQuietly(raf, log); throw Throwables.propagate(e); } catch (FileLockInterruptionException e) { lockFileMap.remove(indexDir); Closeables2.closeQuietly(raf, log); } } } }
@Test public void testLock() throws IOException { FileChannel channel = channel(regularFile(10), READ, WRITE); assertNotNull(channel.lock()); assertNotNull(channel.lock(0, 10, false)); assertNotNull(channel.lock(0, 10, true)); assertNotNull(channel.tryLock()); assertNotNull(channel.tryLock(0, 10, false)); assertNotNull(channel.tryLock(0, 10, true)); FileLock lock = channel.lock(); assertTrue(lock.isValid()); lock.release(); assertFalse(lock.isValid()); }
public static void main(String args[]) throws IOException { if (args.length != 1) { System.err.println("Usage: java LockingExample <input file>"); System.exit(0); } FileLock sharedLock = null; FileLock exclusiveLock = null; try { RandomAccessFile raf = new RandomAccessFile(args[0], "rw"); // get the channel for the file FileChannel channel = raf.getChannel(); System.out.println("trying to acquire lock ..."); // this locks the first half of the file - exclusive exclusiveLock = channel.lock(0, raf.length() / 2, SHARED); System.out.println("lock acquired ..."); /** Now modify the data . . . */ try { // sleep for 10 seconds Thread.sleep(10000); } catch (InterruptedException ie) { } // release the lock exclusiveLock.release(); System.out.println("lock released ..."); // this locks the second half of the file - shared sharedLock = channel.lock(raf.length() / 2 + 1, raf.length(), SHARED); /** Now read the data . . . */ // release the lock sharedLock.release(); } catch (java.io.IOException ioe) { System.err.println(ioe); } finally { if (exclusiveLock != null) exclusiveLock.release(); if (sharedLock != null) sharedLock.release(); } }
public void lock() { try { lockRandomAccessFile = new RandomAccessFile(lockFilePath.toFile(), "rw"); lockChannel = lockRandomAccessFile.getChannel(); lockFile = lockChannel.lock(0, 1024, false); } catch (IOException e) { throw new IllegalStateException("Failed to create lock in " + lockFilePath.toString(), e); } }
public static void main(String[] args) { try { String filename = "fileToLock.dat"; File file = new File(filename); file.createNewFile(); // Creates a random access file stream to read from, and optionally // to write to FileChannel channel = new RandomAccessFile(file, "rw").getChannel(); DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename))); out2.writeDouble(3.14159); out2.writeChars("That was pi\n"); out2.writeBytes("That was pi\n"); out2.close(); // Acquire an exclusive lock on this channel's file ( block until // the region can be // locked, this channel is closed, or the invoking thread is // interrupted) FileLock lock = channel.lock(0, Long.MAX_VALUE, false); System.out.print("Press any key..."); System.in.read(); // Attempts to acquire an exclusive lock on this channel's file // (does not block, an // invocation always returns immediately, either having acquired a // lock on the requested // region or having failed to do so. try { lock = channel.tryLock(0, Long.MAX_VALUE, true); } catch (OverlappingFileLockException e) { // thrown when an attempt is made to acquire a lock on a a file // that overlaps // a region already locked by the same JVM or when another // thread is already // waiting to lock an overlapping region of the same file System.out.println("Overlapping File Lock Error: " + e.getMessage()); } // tells whether this lock is shared boolean isShared = lock.isShared(); // release the lock lock.release(); // close the channel channel.close(); } catch (IOException e) { System.out.println("I/O Error: " + e.getMessage()); } }
@Override public void run() { Database database = input.getDatabase(); Relation<O> relation = database.getRelation(distance.getInputTypeRestriction()); DistanceQuery<O> distanceQuery = database.getDistanceQuery(relation, distance); KNNQuery<O> knnQ = database.getKNNQuery(distanceQuery, DatabaseQuery.HINT_HEAVY_USE); // open file. try (RandomAccessFile file = new RandomAccessFile(out, "rw"); FileChannel channel = file.getChannel(); // and acquire a file write lock FileLock lock = channel.lock()) { // write magic header file.writeInt(KNN_CACHE_MAGIC); int bufsize = k * 12 * 2 + 10; // Initial size, enough for 2 kNN. ByteBuffer buffer = ByteBuffer.allocateDirect(bufsize); FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Computing kNN", relation.size(), LOG) : null; for (DBIDIter it = relation.iterDBIDs(); it.valid(); it.advance()) { final KNNList nn = knnQ.getKNNForDBID(it, k); final int nnsize = nn.size(); // Grow the buffer when needed: if (nnsize * 12 + 10 > bufsize) { while (nnsize * 12 + 10 > bufsize) { bufsize <<= 1; } buffer = ByteBuffer.allocateDirect(bufsize); } buffer.clear(); ByteArrayUtil.writeUnsignedVarint(buffer, it.internalGetIndex()); ByteArrayUtil.writeUnsignedVarint(buffer, nnsize); int c = 0; for (DoubleDBIDListIter ni = nn.iter(); ni.valid(); ni.advance(), c++) { ByteArrayUtil.writeUnsignedVarint(buffer, ni.internalGetIndex()); buffer.putDouble(ni.doubleValue()); } if (c != nn.size()) { throw new AbortException("Sizes did not agree. Cache is invalid."); } buffer.flip(); channel.write(buffer); LOG.incrementProcessed(prog); } LOG.ensureCompleted(prog); lock.release(); } catch (IOException e) { LOG.exception(e); } // FIXME: close! }
/** 演示 用 Channel锁 主文件。 但是 用传统的 io 写入文件 时。是可以写入的。 */ public static void demo1() throws Exception { // 读取的 地址 File fInput = new File(Config.inputAdd); // 创建 一个 读写 操作 RandomAccessFile raf = new RandomAccessFile(fInput, "rw"); // 跳至 文件默认 准备 追加 raf.seek(fInput.length()); FileChannel channel = raf.getChannel(); // true 创建 一个 共享锁 // 如果说 当前 没有其它线程占用。那么这个地方就会返回一个新的 FileLock对象。代表我将文件Config.inputAdd锁定。 // 如果 被其它人 占用 那么就会成 阻塞 模式。不往下继续执行 FileLock fileLock = channel.lock(0, fInput.length(), true); // 重点------>不要忘记lock 是阻塞方式。也就是说。假如现在有另一个线程在使用着这个文件的资源。 // 那么执行到这里。就不会 往下 执行的。 // 直到 另一个线程 释放了 资源。我这个地方 才能返回一个新的 FileLock对象 if (null != fileLock) { System.out.println("已经 获取 到 文件锁"); // 没有 被其他人 占用。或者说已经释放了。 // 目前已经被我自己占用 // 那么第一步 我先读取 // 已经 数据 一次性 的 读取到 内存映射 mbb当中 MappedByteBuffer mbb = channel.map(FileChannel.MapMode.READ_WRITE, 0, fInput.length()); byte[] temp = new byte[(int) fInput.length()]; int foot = 0; while (mbb.hasRemaining()) { temp[foot++] = mbb.get(); } System.out.println(new String(temp)); System.out.println("数据 读取 完毕"); // 在上面 锁没有 释放的情况下,我又往这个文件 写入数据了。 raf.write(temp); System.out.println("数据 写入 完毕"); } else { System.out.println("当前 文件 已经 被其它线程锁定 ---这句话 应该是永远也不会被执行的。 "); } // 释放锁 fileLock.release(); System.out.println("文件锁 已经 释放"); raf.close(); channel.close(); }
public void run() { try { // Exclusive lock with no overlap: FileLock fl = fc.lock(start, end, false); System.out.println("Locked: " + start + " to " + end); // Perform modification: while (buff.position() < buff.limit() - 1) buff.put((byte) (buff.get() + 1)); fl.release(); System.out.println("Released: " + start + " to " + end); } catch (IOException e) { throw new RuntimeException(e); } }
boolean setLock(String rw, long beginIndex, long bytesNum, boolean s) { if (!this.exists()) return false; try { raf = new RandomAccessFile(this, rw); fc = raf.getChannel(); flk = fc.lock(beginIndex, bytesNum, s); } catch (OverlappingFileLockException oe) { LogUtil.warn("[SetLock]", "[No effect]", "the region has already been locked"); return false; } catch (Exception e) { LogUtil.info("[SetLock]", "[No effect]", e); return false; } return true; }
/** * Unlockes file * * @param file target File */ @SuppressWarnings("resource") public static void unlock(File file) { try { FileChannel channel = new RandomAccessFile(file, "rw").getChannel(); FileLock lock = channel.lock(); try { lock = channel.tryLock(); file.setWritable(true); } catch (OverlappingFileLockException e) { } lock.release(); channel.close(); } catch (Exception e) { } }
public static void demo2() throws Exception { // 读取的 地址 File fInput = new File(Config.inputAdd); // 读 FileInputStream fis = new FileInputStream(fInput); // 写 true-->以追加的方式 FileOutputStream fos = new FileOutputStream(fInput, true); // 读 管道 FileChannel inputChannel = fis.getChannel(); // 写管道 FileChannel outputChannel = fos.getChannel(); // 对文件fInput 加 《阻塞》 -> “共享锁” FileLock lock = inputChannel.lock(0, fInput.length(), true); // 重点 提示。如果 有其它线程 在对 fInput文件 上锁。那么这个地方是阻塞的。不会往下执行代码 if (null != lock) { // 说明 当前 fInput文件 没有被 上锁。或者说 已经被释放 System.out.println("文件 没有被上锁 或者 已经被释放锁"); MappedByteBuffer mbb = inputChannel.map(FileChannel.MapMode.READ_ONLY, 0, fInput.length()); System.out.println("数据 已经 被 读取 完毕 "); outputChannel.write(mbb); System.out.println("数据 已经 被 写入 完毕 "); } else { System.out.println("按道理说 这句话 永远 不应该被打印 的....."); } // 释放锁 lock.release(); fis.close(); fos.close(); inputChannel.close(); outputChannel.close(); }
@Test public void testWritesInReadOnlyMode() throws IOException { FileChannel channel = channel(regularFile(0), READ); try { channel.write(buffer("111")); fail(); } catch (NonWritableChannelException expected) { } try { channel.write(buffer("111"), 10); fail(); } catch (NonWritableChannelException expected) { } try { channel.write(new ByteBuffer[] {buffer("111"), buffer("111")}); fail(); } catch (NonWritableChannelException expected) { } try { channel.write(new ByteBuffer[] {buffer("111"), buffer("111")}, 0, 2); fail(); } catch (NonWritableChannelException expected) { } try { channel.transferFrom(new ByteBufferChannel(bytes("1111")), 0, 4); fail(); } catch (NonWritableChannelException expected) { } try { channel.truncate(0); fail(); } catch (NonWritableChannelException expected) { } try { channel.lock(0, 10, false); } catch (NonWritableChannelException expected) { } }
static Properties loadFilePrefsImpl(final File file) { Properties result = new Properties(); if (!file.exists()) { file.getParentFile().mkdirs(); } else if (file.canRead()) { InputStream in = null; FileLock lock = null; try { FileInputStream istream = new FileInputStream(file); // BEGIN android-modified in = new BufferedInputStream(istream, 8192); // END android-modified FileChannel channel = istream.getChannel(); lock = channel.lock(0L, Long.MAX_VALUE, true); Document doc = builder.parse(in); // BEGIN android-modified NodeList entries = selectNodeList(doc.getDocumentElement(), "entry"); // $NON-NLS-1$ // END android-modified int length = entries.getLength(); for (int i = 0; i < length; i++) { Element node = (Element) entries.item(i); String key = node.getAttribute("key"); // $NON-NLS-1$ String value = node.getAttribute("value"); // $NON-NLS-1$ result.setProperty(key, value); } return result; } catch (Exception e) { e.printStackTrace(); } finally { try { lock.release(); } catch (Exception e) { // ignore } try { in.close(); } catch (Exception e) { // ignore } } } else { file.delete(); } return result; }
/** * Opens the given file as a data points file for this RawDataFileImpl instance. If the file is * not empty, the TreeMaps supplied as parameters have to describe the mapping of storage IDs to * data points in the file. */ public synchronized void openDataPointsFile(File dataPointsFileName) throws IOException { if (this.dataPointsFile != null) { throw new IOException("Cannot open another data points file, because one is already open"); } this.dataPointsFileName = dataPointsFileName; this.dataPointsFile = new RandomAccessFile(dataPointsFileName, "rw"); // Locks the temporary file so it is not removed when another instance // of MZmine is starting. Lock will be automatically released when this // instance of MZmine exits. FileChannel fileChannel = dataPointsFile.getChannel(); fileChannel.lock(); // Unfortunately, deleteOnExit() doesn't work on Windows, see JDK // bug #4171239. We will try to remove the temporary files in a // shutdown hook registered in the main.ShutDownHook class dataPointsFileName.deleteOnExit(); }
/** * Simulate a series of read-only queries while holding a shared lock on the index area * * @param fc * @throws Exception */ void doQueries(FileChannel fc) throws Exception { while (true) { System.out.println("trying for shared lock..."); FileLock lock = fc.lock(INDEX_START, INDEX_SIZE, true); int reps = rand.nextInt(60) + 20; for (int i = 0; i < reps; i++) { int n = rand.nextInt(INDEX_COUNT); int position = INDEX_START + (n * SIZEOF_INT); buffer.clear(); fc.read(buffer, position); int value = indexBuffer.get(n); System.out.println("Index entry " + n + "=" + value); Thread.sleep(100); } lock.release(); System.out.print("<sleeping>"); Thread.sleep(rand.nextInt(3000) + 500); } }
public static synchronized void truncateFromBeginning(File f, double pct, File remnant) throws IOException { RandomAccessFile raf = null; RandomAccessFile rafTemp = null; File fTemp = null; try { raf = new RandomAccessFile(f, "rw"); fTemp = remnant == null ? new File(f.getAbsolutePath() + ".tmp") : remnant; rafTemp = fTemp == null ? null : new RandomAccessFile(fTemp, "rw"); FileChannel fc = raf.getChannel(); FileChannel fcTemp = rafTemp == null ? fc : rafTemp.getChannel(); fc.lock(); long oldSize = f.length(); long newSize = (long) (oldSize * (1. - pct)); log.debug("oldSize " + oldSize + ", newSize " + newSize); fc.transferTo(oldSize - newSize, newSize, fcTemp); // transfer // surviving // chunk to temp // file fcTemp.transferTo(0, newSize, fc); // overwrite beginning of log // with surviving chunk fc.truncate(newSize); // trim remaining excess from log } catch (Exception e) { e.printStackTrace(); } finally { try { if (raf != null) { raf.close(); } } finally { try { if (rafTemp != raf && rafTemp != null) { rafTemp.close(); } } finally { if (remnant == null && fTemp != null && fTemp.exists()) { fTemp.delete(); } } } } }
public void run() { try { FileChannel channel = lockFile.getChannel(); /* Get lock B so that write process waits. */ FileLock lockB = channel.lock(2, 1, false); /* Get lock A means write process finish the first phase. */ FileLock lockA = getLockWithReTry(channel, 1, 1); openEnvironments(); /* Release lock A and B so that write process can continue. */ lockB.release(); lockA.release(); /* Read records and check the node equality. */ readRecords(master, prevMasterRecords, replica, prevReplicaRecords); doEqualityCompare(prevMasterRecords, prevReplicaRecords, 100); closeEnvironments(); /* Get lock C means second phase of write process finishes. */ FileLock lockC = getLockWithReTry(channel, 3, 1); /* Reopen and read records, then do the compare. */ openEnvironments(); readRecords(master, newMasterRecords, replica, newReplicaRecords); doEqualityCompare(newMasterRecords, newReplicaRecords, 200); /* Do compare between two snapshots. */ doDiffCompare(prevMasterRecords, newMasterRecords); doDiffCompare(prevReplicaRecords, newReplicaRecords); lockC.release(); } catch (Exception e) { /* Dump exceptions and exit process with value 7.*/ e.printStackTrace(); System.exit(9); } finally { closeEnvironments(); closeLockFile(lockFile); } }
static void flushFilePrefsImpl(File file, Properties prefs) throws IOException { BufferedWriter out = null; FileLock lock = null; try { FileOutputStream ostream = new FileOutputStream(file); // BEGIN android-modified out = new BufferedWriter(new OutputStreamWriter(ostream, "UTF-8"), 8192); // $NON-NLS-1$ // END android-modified FileChannel channel = ostream.getChannel(); lock = channel.lock(); out.write(HEADER); out.newLine(); out.write(FILE_PREFS); out.newLine(); if (prefs.size() == 0) { exportEntries(EMPTY_SARRAY, EMPTY_SARRAY, out); } else { String[] keys = prefs.keySet().toArray(new String[prefs.size()]); int length = keys.length; String[] values = new String[length]; for (int i = 0; i < length; i++) { values[i] = prefs.getProperty(keys[i]); } exportEntries(keys, values, out); } out.flush(); } finally { try { lock.release(); } catch (Exception e) { // ignore } try { if (null != out) { out.close(); } } catch (Exception e) { // ignore } } }
@Test public void testReadsInWriteOnlyMode() throws IOException { FileChannel channel = channel(regularFile(0), WRITE); try { channel.read(buffer("111")); fail(); } catch (NonReadableChannelException expected) { } try { channel.read(buffer("111"), 10); fail(); } catch (NonReadableChannelException expected) { } try { channel.read(new ByteBuffer[] {buffer("111"), buffer("111")}); fail(); } catch (NonReadableChannelException expected) { } try { channel.read(new ByteBuffer[] {buffer("111"), buffer("111")}, 0, 2); fail(); } catch (NonReadableChannelException expected) { } try { channel.transferTo(0, 10, new ByteBufferChannel(buffer("111"))); fail(); } catch (NonReadableChannelException expected) { } try { channel.lock(0, 10, true); } catch (NonReadableChannelException expected) { } }
@SuppressWarnings("resource") protected void openFile() throws IOException { synchronized (locked) { while (locked.containsKey(filename) && locked.get(filename)) { try { locked.wait(); } catch (InterruptedException e) { } } locked.put(filename, true); File file = new File(this.filename); if (!file.exists()) { locked.put(filename, false); locked.notifyAll(); throw new IllegalStateException( "Warning: File doesn't exist (anymore):'" + this.filename + "'"); } channel = new RandomAccessFile(file, "rw").getChannel(); try { // TODO: add support for shared locks, allowing parallel reading // operations. lock = channel.lock(); } catch (Exception e) { channel.close(); channel = null; lock = null; locked.put(filename, false); locked.notifyAll(); throw new IllegalStateException("error, couldn't obtain file lock on:" + filename, e); } fis = new BufferedInputStream(Channels.newInputStream(channel)); fos = new BufferedOutputStream(Channels.newOutputStream(channel)); } }
public static void main(String args[]) throws Exception { // Get file channel RandomAccessFile raf = new RandomAccessFile("usefilelocks.txt", "rw"); FileChannel fc = raf.getChannel(); // Get lock System.out.println("trying to get lock"); FileLock lock = fc.lock(start, end, false); System.out.println("got lock!"); // Pause System.out.println("pausing"); try { Thread.sleep(3000); } catch (InterruptedException ie) { } // Release lock System.out.println("going to release lock"); lock.release(); System.out.println("released lock"); raf.close(); }
/** @tests java.nio.channels.FileLock#isValid() */ public void test_isValid() throws IOException { FileLock fileLock = readWriteChannel.lock(); assertTrue(fileLock.isValid()); fileLock.release(); assertFalse(fileLock.isValid()); }