collections
multithreading
Java Fundamentals
Object Oriented Programming in Java
Java Collections Framework
Exception Handling and Error Management
Java Memory Management
What are the different garbage collectors available in Java and their use cases?
Major collectors: 1) Serial: single-thread, small heaps/applications, 2) Parallel: multiple threads, throughput priority, 3) G1: large heaps, balanced latency/throughput, default since Java 9, 4) ZGC: ultra-low latency, large heaps, 5) Shenandoah: similar to ZGC, different implementation. Choice depends on application requirements: latency, throughput, heap size, and available resources.
What are the key JVM memory-related parameters and how do they affect performance?
Key parameters: 1) -Xmx: maximum heap size, 2) -Xms: initial heap size, 3) -XX:NewRatio: young/old generation ratio, 4) -XX:SurvivorRatio: Eden/Survivor space ratio, 5) -XX:MetaspaceSize: Metaspace size. Best practices: set -Xms=-Xmx to avoid resizing, tune generation sizes based on object lifetime patterns, monitor GC logs for optimization.
How does the G1 (Garbage First) collector work and what are its advantages?
G1 divides heap into equal-sized regions, each can be Eden, Survivor, Old. Works incrementally by collecting regions with most garbage first. Features: predictable pause times, concurrent marking, automatic region sizing, mixed collections. Advantages: reduced fragmentation, better predictability, suitable for large heaps. Requires more CPU resources than Parallel collector.
How do you diagnose and resolve OutOfMemoryError issues?
Diagnosis steps: 1) Analyze heap dumps (using tools like MAT), 2) Enable GC logging, 3) Monitor memory usage patterns, 4) Use profilers. Resolution: identify memory leaks, tune GC parameters, optimize object creation/retention, consider caching strategies, implement proper resource cleanup. Prevention: regular monitoring, load testing, code reviews focusing on memory usage.
What are escape analysis and scalar replacement optimizations?
Escape analysis determines if object allocation can be eliminated. If object doesn't 'escape' method scope, JVM can: 1) Allocate on stack instead of heap, 2) Perform scalar replacement (replace object with its fields), 3) Eliminate synchronization. These optimizations reduce GC pressure and improve performance. Enabled by default but requires proper conditions to trigger.
How do NIO DirectByteBuffers manage memory differently from regular ByteBuffers?
DirectByteBuffers allocate memory outside JVM heap (native memory) for better I/O performance. Implications: 1) Not subject to garbage collection, 2) Manual memory management needed, 3) Higher allocation/deallocation cost, 4) Risk of native memory leaks. Best used for long-lived buffers with significant I/O operations. Requires careful capacity planning and cleanup.
What is the card table in garbage collection and why is it important?
Card table is data structure tracking references from old to young generation, optimizing garbage collection. Divides heap into cards, marks cards when references updated (write barrier). Enables efficient young generation collection by scanning only relevant old generation areas. Critical for generational GC performance but adds slight overhead to reference updates.
How do you implement object pooling in Java and when is it appropriate?
Object pooling reuses objects instead of creating new ones. Implementation: maintain pool of pre-allocated objects, checkout/return methods, size limits, cleanup strategies. Appropriate for: expensive object creation, memory pressure reduction, connection management. Drawbacks: complexity, potential memory leaks, synchronization overhead. Modern JVM optimizations often make pooling unnecessary except for specific cases.
What are memory barriers and how do they affect program performance?
Memory barriers ensure memory operation ordering in concurrent programs. Types: LoadLoad, StoreStore, LoadStore, StoreLoad barriers. Impact performance by preventing CPU/compiler optimizations. Used in volatile variables, synchronization, concurrent collections. Understanding crucial for high-performance concurrent code. JMM (Java Memory Model) defines when barriers required.
How do finalization and reference processing impact garbage collection?
Finalization delays object reclamation, requires two GC cycles. Reference processing (Soft/Weak/Phantom) adds overhead to GC. Both can cause memory leaks if not handled properly. Best practices: avoid finalization (use try-with-resources), carefully manage reference queues, understand reference processing order. Modern Java favors Cleaner over finalizers.
Multithreading and Concurrency
What is the Fork/Join framework and how does it work?
Fork/Join framework (Java 7+) implements divide-and-conquer parallelism. Uses work-stealing algorithm: idle threads steal tasks from busy ones. Components: ForkJoinPool, RecursiveTask (returns result), RecursiveAction (void). Best for CPU-intensive tasks that can be broken into smaller subtasks. Integrates with Stream API for parallel operations.
How do atomic variables work internally and when should they be used?
Atomic variables (AtomicInteger, AtomicReference, etc.) use Compare-And-Swap (CAS) operations for lock-free thread-safety. More efficient than synchronization for single variables. Use when: 1) Single variable updates need atomicity, 2) High contention scenarios, 3) Performance critical code. Limited to single variable operations, complex operations need different approaches.
What is the happens-before relationship and why is it important?
Happens-before relationship defines memory visibility rules between operations. Key relationships: 1) Program order within thread, 2) Monitor lock/unlock, 3) volatile write/read, 4) Thread start/join. Essential for understanding when updates become visible between threads. Forms basis for Java Memory Model's consistency guarantees. Critical for writing correct concurrent code.
How do the different types of ReentrantLock features compare to synchronized?
ReentrantLock advantages over synchronized: 1) Trylock with timeout, 2) Interruptible locking, 3) Fair queueing option, 4) Condition variables, 5) Non-block-structured locking. Disadvantages: explicit unlock required, more complex, easy to misuse. Use when advanced features needed, otherwise prefer synchronized for simplicity and automatic release.
What are memory consistency errors and how can they be avoided?
Memory consistency errors occur when threads have inconsistent views of shared memory due to caching/reordering. Prevention: 1) Proper synchronization, 2) volatile for visibility, 3) final fields for initialization safety, 4) immutable objects, 5) happens-before relationships. Java Memory Model defines when updates must become visible. Tools like JCStress help detect issues.
How does the CompletableFuture API improve asynchronous programming?
CompletableFuture extends Future with composition, chaining, combining operations. Features: 1) Async computation pipelines, 2) Exception handling, 3) Timeout management, 4) Multiple completion stages, 5) Customizable execution. Simplifies async programming compared to callbacks or raw threads. Integrates with reactive programming patterns. Supports both async and sync operations.
How does the Phaser class work and when is it useful?
Phaser is flexible synchronization barrier supporting dynamic party registration. Features: 1) Multiple advance phases, 2) Tree structure for scalability, 3) Arrival/completion monitoring, 4) Termination condition. Use cases: complex phased operations, dynamic thread groups, parallel decomposition. More flexible than CyclicBarrier/CountDownLatch but more complex.
What are lock striping and lock coarsening optimizations?
Lock striping divides single lock into multiple locks for different hashcode ranges (used in ConcurrentHashMap). Lock coarsening combines adjacent synchronized blocks for performance. JVM optimizations reduce synchronization overhead. Trade-off between contention and overhead. Monitor JVM behavior to verify optimizations.
How do you handle thread interruption correctly?
Interruption is cooperative cancellation mechanism. Proper handling: 1) Check/clear interrupted status, 2) Throw InterruptedException or restore flag, 3) Clean up resources, 4) Propagate interruption. Common in blocking operations, long-running tasks. Challenges: third-party code handling, partial results, cleanup. Design for cancellation from start.
What is the Disruptor pattern and when should it be used?
Disruptor is high-performance inter-thread messaging library. Features: 1) Ring buffer for bounded queue, 2) Lock-free design, 3) Cache-friendly, 4) Multiple producer/consumer support. Use for high-throughput scenarios: financial trading, logging, event processing. Requires understanding of memory barriers, cache effects. Complex but highly efficient.
Java I/O and File Handling
How does memory-mapped file I/O work in Java and when should it be used?
Memory-mapped files (MappedByteBuffer) map file content directly to memory. Advantages: 1) Faster access for large files, 2) OS-level optimization, 3) Direct memory access. Best for: large files, random access patterns, shared memory between processes. Limitations: file size constraints, resource management needed. Use FileChannel.map() to create mapping.
How do FileChannel and nio Buffers improve I/O performance?
FileChannel provides direct file access with features: 1) Memory-mapped files, 2) Direct buffer access, 3) File locking, 4) Scatter/gather operations. NIO Buffers offer: 1) Direct memory access, 2) Bulk data operations, 3) Buffer pooling. Performance benefits from: reduced copying, system calls, and better memory usage. Suitable for high-performance I/O.
How does the WatchService API work for monitoring file system events?
WatchService monitors directory for changes (create, modify, delete). Features: 1) Asynchronous notification, 2) Multiple directory monitoring, 3) Platform-specific optimizations. Implementation: register Path with WatchService, process WatchEvents in loop. Considerations: event coalescing, overflow handling, platform differences in sensitivity.
How do you handle large files efficiently in Java?
Strategies: 1) Memory-mapped files for random access, 2) Buffered streams for sequential access, 3) Stream API for processing, 4) Chunked reading/writing, 5) NIO channels for better performance. Consider: memory constraints, access patterns, threading model. Monitor memory usage, use profiling tools. Handle exceptions and cleanup properly.
How does asynchronous I/O work in Java and what are its benefits?
AsynchChannel enables non-blocking I/O operations. Benefits: 1) Improved scalability, 2) Better resource utilization, 3) Reduced thread overhead. Completion handling through: CompletionHandler, Future, or callback. Suitable for: network I/O, many concurrent operations. Requires careful error handling and completion state management.
How do you implement custom serialization using readObject() and writeObject()?
Custom serialization through private readObject()/writeObject() methods. Uses: 1) Control serialization format, 2) Handle sensitive data, 3) Maintain invariants, 4) Version compatibility. Implementation must handle: all fields, superclass state, validation, security. Consider readResolve()/writeReplace() for object replacement.
What is the role of FileVisitor and how is it used for recursive operations?
FileVisitor interface enables traversal of file trees. Methods: preVisitDirectory(), visitFile(), visitFileFailed(), postVisitDirectory(). Uses: recursive operations, filtering, attribute access. SimpleFileVisitor provides default implementations. Handle: cycles, permissions, errors. Consider performance for large directories.
How do you implement file locking in Java and what are the considerations?
File locking through FileChannel: shared (read) or exclusive (write) locks. Considerations: 1) Lock granularity, 2) Cross-process coordination, 3) Deadlock prevention, 4) Platform differences. FileLock must be released explicitly. Useful for concurrent access control. Remember: some platforms don't enforce mandatory locking.
What are the differences between RandomAccessFile and FileChannel for random I/O?
RandomAccessFile: traditional API, synchronized methods, simpler interface. FileChannel: modern API, better performance, more features (memory mapping, locks, etc.). FileChannel advantages: non-blocking operations, bulk transfers, direct buffers. Choose based on: requirements, compatibility needs, performance needs.
Java Generics
How does type erasure affect method overloading with generics?
Type erasure can cause method signature conflicts: List<String> and List<Integer> become same signature after erasure. Bridge methods generated for covariant returns in inheritance. Cannot overload methods differing only in generic type parameters. Solutions: use different method names, add additional parameters, use type tokens. Important for API design and inheritance hierarchies.
What are reifiable and non-reifiable types in Java?
Reifiable types maintain runtime information: primitives, non-generic types, raw types, unbounded wildcards. Non-reifiable types lost during type erasure: generic types with parameters, bounded wildcards. Implications: can't create generic arrays, instanceof limitations, method overloading restrictions. Important for understanding generic type system limitations.
How do you implement a generic singleton pattern?
Generic singleton challenges: 1) Type parameter not available for static methods/fields, 2) Multiple type parameters create multiple instances. Solutions: 1) Generic static factory method, 2) Enum-based implementation, 3) Type token approach. Consider thread safety, serialization. Best practices: limit type parameters, document limitations, consider builder pattern alternative.
How do you work with generic type inheritance?
Generic type inheritance rules: 1) Box<Integer> not subtype of Box<Number> even if Integer extends Number, 2) Generic class inheritance uses type parameters in extends clause, 3) Raw types bypass generic type checking. Bridge methods handle inheritance with different type parameters. Consider bounded type parameters for hierarchies.
What are the limitations of generic array creation and how to work around them?
Cannot create arrays of generic types due to type erasure. Workarounds: 1) Create Object array and cast, 2) Use ArrayList instead, 3) Pass array creation to method parameter, 4) Use reflection (Array.newInstance). Each approach has trade-offs in type safety, performance, complexity. Consider collections as alternative to generic arrays.
How do you use type tokens to work around type erasure?
Type tokens pass Class<T> objects to maintain runtime type information. Uses: 1) Generic factory methods, 2) Type-safe heterogeneous containers, 3) Reflection with generics. Implementation using Class.cast(), instanceof checks. Super type tokens (Neal Gafter) for preserving generic type information. Consider performance implications.
What is recursive type bound and when is it useful?
Recursive type bound: <T extends Comparable<T>>. Uses: 1) Implementing comparable types, 2) Builder pattern with fluent interface, 3) Self-referential generic types. Examples in natural ordering, comparable collections. Ensures type safety in comparison operations. Common in API design for fluent interfaces and type-safe comparisons.
How do you implement generic variance in Java?
Variance handled through wildcards: covariance (? extends T), contravariance (? super T), invariance (T). Use cases: 1) Collection APIs, 2) Method parameters, 3) Return types. Related to Liskov Substitution Principle. Important for API design and collection framework usage. Consider PECS principle for proper usage.
What is heap pollution and how can it occur with generics?
Heap pollution: variable of parameterized type refers to object not of that type. Causes: 1) Mixing raw and generic types, 2) Unchecked warnings, 3) Array covariance with generics. Prevention: 1) Address unchecked warnings, 2) Avoid raw types, 3) Use @SafeVarargs when appropriate. Can lead to runtime failures. Important for type safety.
How do generics interact with reflection?
Reflection with generics challenges: 1) Type erasure limits runtime information, 2) Getting/setting generic types, 3) Creating generic arrays. Solutions: Type tokens, ParameterizedType interface, GenericArrayType. Consider performance impact, maintainability. Useful for frameworks, dependency injection. Document reflection usage clearly.
Java Database Connectivity
Stark.ai
Instant Interviews
