Java FileLock类代码示例

import java.nio.channels.FileLock; //导入依赖的package包/类
private static void release(String lockName, FileLock fileLock, File file, Closeable stream) {
    synchronized (LOCK_MAP) {
        if (fileLock != null) {
            try {
                LOCK_MAP.remove(lockName, fileLock.hashCode());
                ConcurrentHashMap<Integer, ProcessLock> locks = LOCK_MAP.get(lockName);
                if (locks == null || locks.isEmpty()) {
                    IOUtil.deleteFileOrDir(file);
                }

                if (fileLock.channel().isOpen()) {
                    fileLock.release();
                }
            } catch (Throwable ex) {
                LogUtil.e(ex.getMessage(), ex);
            } finally {
                IOUtil.closeQuietly(fileLock.channel());
            }
        }

        IOUtil.closeQuietly(stream);
    }
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
public synchronized int incrementNextTaskId() {
	int toRet = -1;
	try {
		FileLock l = channel.lock();
		buffer.position(0);
		int current = buffer.getInt();
		buffer.position(0);
		current++;
		toRet = current;
		buffer.putInt(current);
		l.release();
	} catch (IOException e) {
		System.err.println("SharedSystemData, IOException : " + e.getMessage());
		e.printStackTrace();
	}
	
	return toRet;
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
 * Compactar uma arquivo.
 * @param inputFile informar o arquivo a ser compactado.
 * @param zipFilePath informar o nome e caminho zip.
 * @param iZipFile se necessário, informar uma {@link IZipFile}.
 * @throws IOException
 */
public static void zipFile(File inputFile, String zipFilePath, IZipFile iZipFile) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream(zipFilePath);
    ZipOutputStream zipOutputStream = new ZipOutputStream(fileOutputStream);
    ZipEntry zipEntry = new ZipEntry(inputFile.getName());
    zipOutputStream.putNextEntry(zipEntry);
    FileInputStream fileInputStream = new FileInputStream(inputFile);
    FileChannel fileChannel = fileInputStream.getChannel();
    FileLock fileLock = fileChannel.tryLock(0L, Long.MAX_VALUE, /*shared*/true);
    long sizeToZip = fileInputStream.available();
    long sizeCompacted = 0;
    try {
        byte[] buf = new byte[1024];
        int bytesRead;
        while ((bytesRead = fileInputStream.read(buf)) > 0) {
            sizeCompacted += bytesRead;
            zipOutputStream.write(buf, 0, bytesRead);
            if (iZipFile != null) iZipFile.progress(sizeToZip, sizeCompacted);
        }
    } finally {
        fileLock.release();
        zipOutputStream.closeEntry();
        zipOutputStream.close();
        fileOutputStream.close();
    }
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
public void testOperationActions() throws Exception { // #72397
    final NbModuleProject project = generateStandaloneModule("module");
    cgpi.setProject(project);
    DialogDisplayerImpl dd = (DialogDisplayerImpl) Lookup.getDefault().lookup(DialogDisplayer.class);
    FileObject lock = FileUtil.createData(project.getProjectDirectory(), "build/testuserdir/lock");
    RandomAccessFile raf = new RandomAccessFile(FileUtil.toFile(lock), "rw");
    FileLock lck = raf.getChannel().lock();
    EventQueue.invokeAndWait(new Runnable() {
        @Override public void run() {
            ((ContextAwareAction) CommonProjectActions.deleteProjectAction()).createContextAwareInstance(Lookups.singleton(project)).actionPerformed(null);
        }
    });
    assertNotNull("warning message emitted", dd.getLastNotifyDescriptor());
    assertEquals("warning message emitted", dd.getLastNotifyDescriptor().getMessage(),
            Bundle.ERR_ModuleIsBeingRun());
    dd.reset();
    lck.release();
    raf.close();
    lock.delete();
    EventQueue.invokeAndWait(new Runnable() {
        @Override public void run() {
            CommonProjectActions.deleteProjectAction().actionPerformed(null);
        }
    });
    assertNull("no warning message", dd.getLastNotifyDescriptor());
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
	 * Will modify length of section if differnt amoutn actually written
	 * @param writeSection
	 * @param sourceChannel
	 * @throws IOException
	 */
	private void writeFromSocketChannel(Section writeSection, SocketChannel sourceChannel) throws IOException{
			synchronized (sourceChannel) {
				try (
						FileLock sectionLock = pieceChannel.lock(Integer.toUnsignedLong(writeSection.begin), Integer.toUnsignedLong(writeSection.length), false)
					)
					{
//					System.out.println("dksahfksjadh");
						int plz = writeSection.length;
						//writeSection.length = Math.toIntExact(pieceChannel.transferFrom(sourceChannel, Integer.toUnsignedLong(writeSection.begin), Integer.toUnsignedLong(writeSection.length)));
						ByteBuffer cant = ByteBuffer.allocate(plz);
						cant.clear();
						sourceChannel.read(cant);
						cant.rewind();
						pieceChannel.write(cant, writeSection.begin);
						
						
//						System.out.println("LENGTH ACTUALLY:  " + plz);

					};
			}
		
			
	}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
 * Unlock file already locked with {@link #lockFile(String) lockFile()} method
 *
 * @param fileName file name
 */
@Override
public void unlockFile(
                        String fileName ) {

    synchronized (lockedFiles) {

        FileLock fileLock = lockedFiles.get(fileName);
        if (fileLock != null) {
            try {
                fileLock.release();
            } catch (Exception e) {
                throw new FileSystemOperationException("Could not unlock file '" + fileName + "'", e);
            } finally {
                IoUtils.closeStream(fileLock.channel());
                lockedFiles.remove(fileName);
            }
        } else {
            log.warn("File '" + fileName + "' is not locked, so we will not try to unlock it");
        }
    }
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
 * Attempts to acquire an exclusive lock on the directory.
 *
 * @return A lock object representing the newly-acquired lock or
 * <code>null</code> if directory is already locked.
 * @throws IOException if locking fails.
 */
@SuppressWarnings("resource")
private FileLock tryLock(File dir) throws IOException {
  File lockF = new File(dir, FILE_LOCK);
  lockF.deleteOnExit();
  RandomAccessFile file = new RandomAccessFile(lockF, "rws");
  FileLock res = null;
  try {
    res = file.getChannel().tryLock();
  } catch (OverlappingFileLockException oe) {
    file.close();
    return null;
  } catch (IOException e) {
    LOGGER.error("Cannot create lock on " + lockF, e);
    file.close();
    throw e;
  }
  return res;
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
private File unzipFile(File cachedFile) throws IOException {
  String filename = cachedFile.getName();
  File destDir = new File(cachedFile.getParentFile(), filename + "_unzip");
  if (!destDir.exists()) {
    File lockFile = new File(cachedFile.getParentFile(), filename + "_unzip.lock");
    FileOutputStream out = new FileOutputStream(lockFile);
    try {
      FileLock lock = out.getChannel().lock();
      try {
        // Recheck in case of concurrent processes
        if (!destDir.exists()) {
          Path tempDir = fileCache.createTempDir();
          ZipUtils.unzip(cachedFile, tempDir.toFile(), newLibFilter());
          FileUtils.moveDirectory(tempDir.toFile(), destDir);
        }
      } finally {
        lock.release();
      }
    } finally {
      out.close();
      FileUtils.deleteQuietly(lockFile);
    }
  }
  return destDir;
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
 * Tries to obtain a write lock on the file. This can be used to verify that no other processes concurrently
 * writes to the file, for example to check that writing to a file, i.e. on a MODIFY_ENTRY event, is completed
 * @param path
 *  the path to the file
 * @return
 *  true, if the lock could be obtained. False, if not. Please not that the lock is released once the method
 *  returns!
 */
public static boolean tryWriteLock(final Path path) {
    try(FileChannel ch = FileChannel.open(path, StandardOpenOption.WRITE);
        FileLock lock = ch.lock()){

        if(lock == null) {
            LOG.log(Level.INFO, "Could not obtain lock on file, maybe still writing");
            return false;
        } else {
            return true;
        }
    } catch (IOException e) {
        LOG.log(Level.INFO, "File not open for write access", e);
        return false;
    }
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/** write lock file to prevent duplicate execution */
@SuppressWarnings("resource")
public static void fileLock() throws FileNotFoundException {
	lockFile = new File(Main.LOCK_FILE_LOCATION);

	FileChannel channel;
	channel = new RandomAccessFile(lockFile, "rw").getChannel();

	// try lock
	FileLock lock;
	try {
		lock = channel.tryLock();
		// already obtain lock in other JVM
		if (lock == null) {
			channel.close();
			System.exit(0);
		}
	} catch (IOException e) {
		// error handle
	}
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
void releaseLock(final FileLock fileLock, final File lockFile) throws IOException {
  if (lockFile == null) {
    return;
  }

  try {
    if (fileLock != null) {
      fileLock.release();
      fileLock.channel().close();
    }
  } finally {
    if (!lockFile.delete()) {
      lockFile.deleteOnExit();
    }
  }
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
private ShareFileLockHelper(File lockFile) throws IOException {
    this.outputStream = new FileOutputStream(lockFile);
    int numAttempts = 0;
    FileLock localFileLock = null;
    Exception saveException = null;
    while (numAttempts < 3) {
        numAttempts++;
        try {
            localFileLock = this.outputStream.getChannel().lock();
            if (localFileLock != null) {
                break;
            }
            Thread.sleep(10);
        } catch (Exception e) {
            saveException = e;
            Log.e(TAG, "getInfoLock Thread failed time:10");
        }
    }
    if (localFileLock == null) {
        throw new IOException("Tinker Exception:FileLockHelper lock file failed: " + lockFile
                .getAbsolutePath(), saveException);
    }
    this.fileLock = localFileLock;
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
@Override
public boolean isPreUpgradableLayout(StorageDirectory sd) throws IOException {
  File oldF = new File(sd.getRoot(), "storage");
  if (!oldF.exists())
    return false;
  // check the layout version inside the storage file
  // Lock and Read old storage file
  RandomAccessFile oldFile = new RandomAccessFile(oldF, "rws");
  FileLock oldLock = oldFile.getChannel().tryLock();
  try {
    oldFile.seek(0);
    int oldVersion = oldFile.readInt();
    if (oldVersion < LAST_PRE_UPGRADE_LAYOUT_VERSION)
      return false;
  } finally {
    oldLock.release();
    oldFile.close();
  }
  return true;
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
 * Lock storage to provide exclusive access.
 * 
 * <p> Locking is not supported by all file systems.
 * E.g., NFS does not consistently support exclusive locks.
 * 
 * <p> If locking is supported we guarantee exclusive access to the
 * storage directory. Otherwise, no guarantee is given.
 * 
 * @throws IOException if locking fails
 */
public void lock() throws IOException {
  if (isShared()) {
    LOG.info("Locking is disabled for " + this.root);
    return;
  }
  FileLock newLock = tryLock();
  if (newLock == null) {
    String msg = "Cannot lock storage " + this.root 
      + ". The directory is already locked";
    LOG.info(msg);
    throw new IOException(msg);
  }
  // Don't overwrite lock until success - this way if we accidentally
  // call lock twice, the internal state won't be cleared by the second
  // (failed) lock attempt
  lock = newLock;
}
 

import java.nio.channels.FileLock; //导入依赖的package包/类
/**
 * Check whether underlying file system supports file locking.
 * 
 * @return <code>true</code> if exclusive locks are supported or
 *         <code>false</code> otherwise.
 * @throws IOException
 * @see StorageDirectory#lock()
 */
public boolean isLockSupported() throws IOException {
  FileLock firstLock = null;
  FileLock secondLock = null;
  try {
    firstLock = lock;
    if(firstLock == null) {
      firstLock = tryLock();
      if(firstLock == null)
        return true;
    }
    secondLock = tryLock();
    if(secondLock == null)
      return true;
  } finally {
    if(firstLock != null && firstLock != lock) {
      firstLock.release();
      firstLock.channel().close();
    }
    if(secondLock != null) {
      secondLock.release();
      secondLock.channel().close();
    }
  }
  return false;
}