/** * 检查文件是否上锁 * * @return * @throws IOException */ public boolean validateFile() throws IOException { fileUrl = System.getProperty("user.dir") + "/SpiderRun.lock"; File myfilelock = new File(fileUrl); RandomAccessFile raf = null; FileChannel fc = null; if (!myfilelock.exists()) { // 不存在,则新增文件,然后加锁 raf = new RandomAccessFile(myfilelock, "rw"); fc = raf.getChannel(); FileLock fl = fc.tryLock(); if (fl != null && fl.isValid()) { // System.err.println(fileUrl + "文件被创建且被锁!"); return false; } } else { // 存在,判断是否被锁 raf = new RandomAccessFile(myfilelock, "rw"); fc = raf.getChannel(); FileLock fl = fc.tryLock(); if (fl != null && fl.isValid()) { // 被锁 System.err.println(fileUrl + "文件已被锁,请删除后,再启动该进程!"); return true; } } return false; }
@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) { } }
/** * Try to open the file. * * @param fileName the file name * @param readOnly whether the file should only be opened in read-only mode, even if the file is * writable * @param encryptionKey the encryption key, or null if encryption is not used */ public void open(String fileName, boolean readOnly, char[] encryptionKey) { if (file != null) { return; } if (fileName != null) { FilePath p = FilePath.get(fileName); // if no explicit scheme was specified, NIO is used if (p instanceof FilePathDisk && !fileName.startsWith(p.getScheme() + ":")) { // ensure the NIO file system is registered FilePathNio.class.getName(); fileName = "nio:" + fileName; } } this.fileName = fileName; FilePath f = FilePath.get(fileName); FilePath parent = f.getParent(); if (parent != null && !parent.exists()) { throw DataUtils.newIllegalArgumentException("Directory does not exist: {0}", parent); } if (f.exists() && !f.canWrite()) { readOnly = true; } this.readOnly = readOnly; try { file = f.open(readOnly ? "r" : "rw"); if (encryptionKey != null) { byte[] key = FilePathEncrypt.getPasswordBytes(encryptionKey); encryptedFile = file; file = new FilePathEncrypt.FileEncrypt(fileName, key, file); } file = FilePathCache.wrap(file); try { if (readOnly) { fileLock = file.tryLock(0, Long.MAX_VALUE, true); } else { fileLock = file.tryLock(); } } catch (OverlappingFileLockException e) { throw DataUtils.newIllegalStateException( DataUtils.ERROR_FILE_LOCKED, "The file is locked: {0}", fileName, e); } if (fileLock == null) { throw DataUtils.newIllegalStateException( DataUtils.ERROR_FILE_LOCKED, "The file is locked: {0}", fileName); } fileSize = file.size(); } catch (IOException e) { throw DataUtils.newIllegalStateException( DataUtils.ERROR_READING_FAILED, "Could not open file {0}", fileName, e); } }
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; } }
public boolean isLocked() { try { channel = new RandomAccessFile(file, "rw").getChannel(); try { lock = channel.tryLock(); } catch (OverlappingFileLockException e) { close(); return true; } if (lock == null) { close(); return true; } hook = new Thread() { @Override public void run() { close(); deleteFile(); } }; Runtime.getRuntime().addShutdownHook(hook); return false; } catch (Exception e) { close(); return true; } }
public static boolean isAppActive() { try { file = new File(System.getProperty("user.home"), appName + ".tmp"); channel = new RandomAccessFile(file, "rw").getChannel(); try { lock = channel.tryLock(); } catch (OverlappingFileLockException e) { // already locked closeLock(); return true; } if (lock == null) { closeLock(); return true; } Runtime.getRuntime() .addShutdownHook( new Thread() { // destroy the lock when the JVM is closing public void run() { closeLock(); deleteFile(); } }); return false; } catch (Exception e) { closeLock(); return true; } }
public StorageRootFile(String dbPath, String options, int pageSize, FreeSpaceManager fsm) { this.fsm = fsm; PAGE_SIZE = pageSize; File file = new File(dbPath); if (!file.exists()) { throw DBLogger.newUser("DB file does not exist: " + dbPath); } try { raf = new RandomAccessFile(file, options); fc = raf.getChannel(); try { // tryLock is supposed to return null, but it throws an Exception fileLock = fc.tryLock(); if (fileLock == null) { fc.close(); raf.close(); throw DBLogger.newUser("This file is in use by another process: " + dbPath); } } catch (OverlappingFileLockException e) { fc.close(); raf.close(); throw DBLogger.newUser("This file is in use by another PersistenceManager: " + dbPath); } if (ZooDebug.isTesting()) { ZooDebug.registerFile(fc); } } catch (IOException e) { throw DBLogger.newFatal("Error opening database: " + dbPath, e); } }
public OneInstanceGuard(String lockFileName) { lockFile = new File(lockFileName); if (lockFile.exists()) { lockFile.delete(); } try { channel = new RandomAccessFile(lockFile, "rw").getChannel(); } catch (FileNotFoundException e) { // Not running LOG.info("File not found: " + e); return; } try { lock = channel.tryLock(); if (lock == null) { // File is lock by other application channel.close(); throw new IOException("Instance already active"); } } catch (IOException e) { // Running LOG.info("Instance already running"); alreadyRunning = true; return; } ShutdownHook shutdownHook = new ShutdownHook(this); Runtime.getRuntime().addShutdownHook(shutdownHook); }
/** Reply a specific WAL. */ private void replayLog(Path logPath) throws KevaDBException { // Now look at the disk. if (logPath != null) { // Get a list of the sstables already in place. Map<String, Integer> manifest = db.getDiskService().getDataManifests(db, 0, SSTableService.MAX_LEVELS); FileLock fileLock = null; try { // Must open in "rw" mode so that we can use filelock. FileChannel fc = FileChannel.open(logPath, StandardOpenOption.READ, StandardOpenOption.WRITE); MappedByteBuffer in = fc.map(FileChannel.MapMode.READ_ONLY, 0, (int) fc.size()); fileLock = fc.tryLock(); if (fileLock != null) { for (; ; ) { if (!unroll(in, manifest)) { break; } } } if (fileLock != null) { fileLock.release(); } fc.close(); } catch (IOException e) { e.printStackTrace(); } } }
/** * @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; }
@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 FileLock getFileLock(FileChannel fileChannel) { try { return fileChannel.tryLock(); } catch (Exception e) { _logger.error(e.getMessage(), e); return null; } }
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 synchronized FileLock tryLock(long position, long size, boolean shared) throws IOException { FileLock l = channel.tryLock(position, size, shared); if (l == null) { return null; } lock = new FileLockRetry(l, this); return lock; }
/* Get a FileLock with retry. */ private static FileLock getLockWithReTry(FileChannel channel, long position, long size) throws Exception { int retries = 0; FileLock lock = channel.tryLock(position, size, false); while (lock == null && retries <= MAX_RETRIES) { Thread.sleep(1000); lock = channel.tryLock(position, size, false); retries++; } if (lock == null) { System.err.println("Can't get a FileLock during " + MAX_RETRIES + " seconds."); System.exit(6); } return lock; }
/** * Creates and initializes an SPV block store. Will create the given file if it's missing. This * operation will block on disk. */ public SPVBlockStore(NetworkParameters params, File file) throws BlockStoreException { checkNotNull(file); this.params = checkNotNull(params); try { this.numHeaders = DEFAULT_NUM_HEADERS; boolean exists = file.exists(); // Set up the backing file. randomAccessFile = new RandomAccessFile(file, "rw"); long fileSize = getFileSize(); if (!exists) { log.info("Creating new SPV block chain file " + file); randomAccessFile.setLength(fileSize); } else if (randomAccessFile.length() != fileSize) { throw new BlockStoreException( "File size on disk does not match expected size: " + randomAccessFile.length() + " vs " + fileSize); } FileChannel channel = randomAccessFile.getChannel(); fileLock = channel.tryLock(); if (fileLock == null) throw new BlockStoreException("Store file is already locked by another process"); // Map it into memory read/write. The kernel will take care of flushing writes to disk at the // most // efficient times, which may mean that until the map is deallocated the data on disk is // randomly // inconsistent. However the only process accessing it is us, via this mapping, so our own // view will // always be correct. Once we establish the mmap the underlying file and channel can go away. // Note that // the details of mmapping vary between platforms. buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, fileSize); // Check or initialize the header bytes to ensure we don't try to open some random file. byte[] header; if (exists) { header = new byte[4]; buffer.get(header); if (!new String(header, "US-ASCII").equals(HEADER_MAGIC)) throw new BlockStoreException("Header bytes do not equal " + HEADER_MAGIC); } else { initNewStore(params); } } catch (Exception e) { try { if (randomAccessFile != null) randomAccessFile.close(); } catch (IOException e2) { throw new BlockStoreException(e2); } throw new BlockStoreException(e); } }
public boolean tryLock() { try { lockRandomAccessFile = new RandomAccessFile(lockFilePath.toFile(), "rw"); lockChannel = lockRandomAccessFile.getChannel(); lockFile = lockChannel.tryLock(0, 1024, false); return lockFile != null; } catch (IOException e) { throw new IllegalStateException("Failed to create lock in " + lockFilePath.toString(), e); } }
public static void test() throws IOException, InterruptedException { FileOutputStream out = new FileOutputStream("tt.txt"); FileChannel fileChannel = out.getChannel(); FileLock lock = fileChannel.tryLock(); System.out.println(lock); for (int i = 0; i < 10; i++) { out.write("fjsdlfjsdlf".getBytes()); out.write("\n".getBytes()); } out.flush(); out.close(); Thread.sleep(10000); }
private void reLock() throws IOException { if (lock == null) { return; } try { lock.base.release(); } catch (IOException e) { // ignore } FileLock l2 = channel.tryLock(lock.position(), lock.size(), lock.isShared()); if (l2 == null) { throw new IOException("Re-locking failed"); } lock.base = l2; }
/** * 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 DbLock(File lockFile) throws IOException { Preconditions.checkNotNull(lockFile, "lockFile is null"); this.lockFile = lockFile; // open and lock the file channel = new RandomAccessFile(lockFile, "rw").getChannel(); try { lock = channel.tryLock(); } catch (IOException e) { Closeables.closeQuietly(channel); throw e; } if (lock == null) { throw new IOException(format("Unable to acquire lock on '%s'", lockFile.getAbsolutePath())); } }
/** * Check system exec only one pro <br> * Created on: Nov 23, 2012 11:23:15 AM * * @param fileName * @return */ public static boolean tryLock(String fileName) { /** A token representing a lock on a region of a file. */ FileLock lock = null; /** A channel for reading, writing, mapping, and manipulating a file. */ FileChannel channel = null; /** Instances of this class support both reading and writing to a random access file. */ RandomAccessFile randomAccessFile = null; try { randomAccessFile = new RandomAccessFile(fileName, "rw"); if (null != randomAccessFile) { channel = randomAccessFile.getChannel(); } if (null != channel) { lock = channel.tryLock(); } return (null != lock && lock.isValid()); } catch (FileNotFoundException e) { System.out.println(" Project lock file [" + fileName + "] error ! PORGRAMME EXIT."); System.out.println( "MASSAGE : " + e.getMessage() + "\nCAUSE : " + e.getCause() + "\nCLASS : " + e.getClass()); System.exit(1); } catch (IOException e) { System.out.println(" Project lock file [" + fileName + "] error ! PORGRAMME EXIT."); System.out.println( "MASSAGE : " + e.getMessage() + "\nCAUSE : " + e.getCause() + "\nCLASS : " + e.getClass()); System.exit(1); } return false; }
private static void unlockFile(File file) { try { RandomAccessFile raf = new RandomAccessFile(file, "rw"); FileChannel channel = raf.getChannel(); try { if (channel.tryLock() == null) { // File is locked log.warn("File " + file.getAbsolutePath() + " is locked and couldn't be released"); return; } } finally { channel.close(); // Unlock in either case } } catch (IOException e) { e.printStackTrace(); log.error("Couldn't unlock " + file, e); } }
private FileLock obtainLock(FileChannel channel, boolean shared) throws TimeoutException, IOException { FileLock lock = null; int attempts = 0; try { /** Using 0x7fffffff in place of Long.MAX_VALUE. Bug # 4719967,4719605 * */ while ((lock = channel.tryLock(0L, 0x7fffffff, shared)) == null && attempts++ < ATTEMPTS) { Thread.currentThread().sleep(TIMEOUT); } } catch (InterruptedException e) { throw new TimeoutException(); } if (lock == null) { throw new TimeoutException(); } return lock; }
private void lock() throws IOException, BlockStoreException { if (!semaphores.tryAcquire(fileName)) { throw new BlockStoreException("File in use"); } try { lock = channel.tryLock(); } catch (OverlappingFileLockException e) { semaphores.release(fileName); lock = null; } if (lock == null) { try { this.file.close(); } finally { this.file = null; } throw new BlockStoreException("Could not lock file"); } }
/* * TODO: Finish method. */ public static String readBytesFromFile(File filename) throws IOException, OverlappingFileLockException { if (!filename.exists()) { return null; } try { ByteBuffer buffer = ByteBuffer.allocate(((int) filename.getTotalSpace() * 4)); fileReader = new FileInputStream(filename).getChannel(); FileLock lock = fileReader.tryLock(); if (lock != null) { fileReader.read(buffer); } else { throw new OverlappingFileLockException(); } } finally { fileWriter.close(); } return ""; }
public static FileLock tryLock(File file) { FileLock toReturn = null; try { RandomAccessFile raf = new RandomAccessFile(file, "rw"); try { FileChannel channel = raf.getChannel(); toReturn = channel.tryLock(); raf.writeBytes("lock file for: " + ManagementFactory.getRuntimeMXBean().getName()); } finally { if (toReturn == null) raf.close(); } } catch (OverlappingFileLockException e) { toReturn = null; } catch (FileNotFoundException e) { toReturn = null; } catch (IOException e) { toReturn = null; } return toReturn; }
/* * (non-Javadoc) * * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, * javax.servlet.ServletResponse, javax.servlet.FilterChain) */ public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain) throws IOException, ServletException { if (!(req instanceof HttpServletRequest) || !(resp instanceof HttpServletResponse)) { filterChain.doFilter(req, resp); return; } HttpServletRequest request = (HttpServletRequest) req; HttpServletResponse response = (HttpServletResponse) resp; String servletPath = request.getServletPath(); Page p = pageMappings.get(servletPath); if (p == null) { // 不需要静态化的页面 filterChain.doFilter(request, response); return; } String filePath = findStaticPage(request, p); File file = new File(pagesLocation, filePath); File etagFile = new File(pagesLocation, filePath + ".etag"); FileOutputStream out = null; boolean fileLocked = true; String etagServer = findEtag(etagFile); String etagClient = request.getHeader("If-None-Match"); boolean fileValid = file.isFile() && file.length() > 0 && etagServer != null; long expired = 0; if (p.cronExpression != null) { expired = p.cronExpression.getNextValidTimeAfter(new Date(file.lastModified())).getTime() - System.currentTimeMillis(); } else { if (p.refreshInterval == Long.MAX_VALUE) { expired = Long.MAX_VALUE; } else { expired = System.currentTimeMillis() - file.lastModified(); expired = expired > 0 ? p.refreshInterval - expired : p.refreshInterval; } } fileValid = fileValid && expired > 0; if (fileValid) { try { // 文件已存在,加共享锁,防止读取脏数据,同步块要尽可能的小,提高并发性 out = new FileOutputStream(file, true); FileChannel fc = out.getChannel(); FileLock fileLock = fc.tryLock(0, Long.MAX_VALUE, false); fileLocked = (fileLock == null || !fileLock.isValid()); } catch (Exception ex) { fileLocked = true; } finally { if (out != null) { // 关闭共享锁文件流 try { out.close(); } catch (Exception ex) { } } } } else { try { // 清除不合法静态文件 if (!file.isFile() || file.delete()) { file.getParentFile().mkdirs(); file.createNewFile(); // 文件不存在加排他锁,防止重复写入,同步块要尽可能的小,提高并发性 out = new FileOutputStream(file); try { FileChannel fc = out.getChannel(); FileLock fileLock = fc.tryLock(); fileLocked = (fileLock == null || !fileLock.isValid()); } catch (Exception ex) { fileLocked = true; } // double check lock etagServer = findEtag(etagFile); fileValid = file.isFile() && file.length() > 0 && etagServer != null; if (p.cronExpression != null) { expired = p.cronExpression.getNextValidTimeAfter(new Date(file.lastModified())).getTime() - System.currentTimeMillis(); } else { if (p.refreshInterval == Long.MAX_VALUE) { expired = Long.MAX_VALUE; } else { expired = System.currentTimeMillis() - file.lastModified(); expired = expired > 0 ? p.refreshInterval - expired : p.refreshInterval; } } fileValid = fileValid && expired > 0; } else { fileLocked = true; } } catch (Exception ex) { fileLocked = true; } finally { if (fileLocked && out != null) { // 关闭排他锁文件流 try { out.close(); } catch (Exception ex) { } } } } if (fileLocked) { // 静态页面正在写入,跳过静态化 if (expired != Long.MAX_VALUE) { expired = expired < 0 ? 0 : expired / 1000; response.setHeader("cache-control", "max-age=" + expired); } filterChain.doFilter(request, response); return; } if (fileValid) { response.setHeader("etag", etagServer); if (etagServer.equalsIgnoreCase(etagClient)) { response.setStatus(HttpServletResponse.SC_NOT_MODIFIED); } else { // 静态页面合法,直接跳转过去 StringBuilder sb = new StringBuilder(); sb.append(prefix); sb.append(filePath); if ("web".equals(xSendFileKey)) { // 直接使用web容器返回 RequestDispatcher dispatcher = request.getRequestDispatcher(sb.toString()); dispatcher.forward(request, response); } else { // 使用http服务器进行加速 response.setHeader(xSendFileKey, sb.toString()); if (expired != Long.MAX_VALUE) { expired = expired < 0 ? 0 : expired / 1000; response.setHeader("cache-control", "max-age=" + expired); } } } } else { // 静态页面不存在或者已过期 StaticizeResponse res = null; try { res = new StaticizeResponse(response, out, file); if (expired != Long.MAX_VALUE) { expired = expired < 0 ? 0 : expired / 1000; response.setHeader("cache-control", "max-age=" + expired); } // md5还没生成先写入空值的md5值,下次请求返回正确的md5值 response.setHeader("etag", "d41d8cd98f00b204e9800998ecf8427e"); filterChain.doFilter(request, res); } finally { if (res != null) { try { res.flushBuffer(); res.close(); } catch (Exception ex) { } etagServer = res.getMd5(); saveEtag(etagFile, etagServer); } } } }
@Override public FileLock tryLock(long position, long size, boolean shared) throws IOException { return base.tryLock(position, size, shared); }
@Override public synchronized FileLock tryLock(long position, long size, boolean shared) throws IOException { return readBase.tryLock(position, size, shared); }