/** * @return partition between 0 inclusive * and partitions exclusive */ int partition(Track track, int partitions) { assert track != null; assert partitions > 0; return track.hashCode() % partitions; }
return Math.abs( track.hashCode() ) % partitions;
return Math.abs( track.hashCode() % partitions );
void cleanup(Path dir) throws IOException { for (Path file : Files.newDirectoryStream(dir)) { if (file.endsWith(".tmp")) { Files.delete(file); } } }
void cleanup(Path dir) throws IOException { try ( DirectoryStream<Path> stream = Files.newDirectoryStream(dir) ) { for (Path file : stream) { if (file.endsWith(".tmp")) { Files.delete(file); } } } }
var
in order for the program to compile?
var list = Arrays.asList("1", 2, 3.0);
List<?>
List<? super Comparable>
List<? extends Comparable>
List<? extends Comparable & Serializable>
List<? super Comparable & Serializable>
class ConcurrencyLimiter { static final int DEFAULT_LIMIT = 10; final Semaphore semaphore = new Semaphore(DEFAULT_LIMIT); void runTask(Runnable task) { semaphore.acquireUninterruptibly(); try { task.run(); } finally { semaphore.release(); } } // Implement me void setLimit(int newLimit) { assert newLimit > 0; // TODO: Implementation pending } }
// Implemented final AtomicInteger limit = new AtomicInteger(DEFAULT_LIMIT); void setLimit(int newLimit) { assert newLimit > 0; final int previous = limit.getAndSet(newLimit); if (newLimit >= previous) { semaphore.release(newLimit - previous); } else { semaphore.acquireUninterruptibly(previous - newLimit); } }
// Implemented final AtomicInteger limit = new AtomicInteger(DEFAULT_LIMIT); void setLimit(int newLimit) { assert newLimit > 0; final int previous = limit.getAndSet(newLimit); if (newLimit >= previous) { semaphore.release(newLimit - previous); } else { // magic goes here: for ( int i = 0; i < previous - newLimit; i++) semaphore.acquireUninterruptibly(1); } }
Source: https://habr.com/ru/post/353006/