面试题与答案

Multithreading is the concurrent execution of two or more threads to achieve parallelism in a program.

Example:

In Java, you can create a multithreaded program by extending the Thread class or implementing the Runnable interface.

You can create a thread by extending the Thread class or implementing the Runnable interface.

Example:

Example using Thread class: 
class MyThread extends Thread { 
public void run() { 
/* Thread logic */ 
} 
}

The sleep() method is used to pause the execution of the current thread for a specified amount of time.

Example:

try { Thread.sleep(1000); } 
catch (InterruptedException e) { e.printStackTrace(); }

The yield() method is used to make the currently executing thread voluntarily pause, allowing other threads to execute.

Example:

Thread.yield();

Thread is a class in Java that provides methods to create and perform operations on a thread. Runnable is an interface that must be implemented by a class to be executed by a thread.

Example:

class MyRunnable implements Runnable { 
public void run() 
{ /* Runnable logic */
 } 
}

You can achieve synchronization in Java using the synchronized keyword or using locks.

Example:

Example using synchronized keyword: 
synchronized void myMethod() { /* Synchronized code */ }

Thread safety is a property that ensures that a block of code or a class can be safely executed by multiple threads concurrently without causing data corruption.

Example:

Using synchronized methods or blocks to control access to shared resources.

A Thread Pool is a group of pre-initialized, reusable threads that are available to perform a set of tasks.

Example:

ExecutorService executor = Executors.newFixedThreadPool(5);

The volatile keyword in Java is used to indicate that a variable's value may be changed by multiple threads simultaneously.

Example:

volatile int sharedVariable = 0;

A daemon thread is a background thread that runs intermittently and is terminated when all non-daemon threads have completed.

Example:

Thread daemonThread = new Thread(() -> { 
/* Daemon thread logic */ }); 
daemonThread.setDaemon(true);

The interrupt() method is used to interrupt the execution of a thread. It sets the interrupted flag, causing the thread to stop if it's in a sleeping or waiting state.

Example:

Thread myThread = new Thread(() -> { 
while (!Thread.interrupted()) { 
/* Thread logic */ 
} 
}); 
myThread.start(); 
myThread.interrupt();

Thread-local variables are variables that are local to each thread, and each thread has its own copy of the variable.

Example:

ThreadLocal threadLocalVariable = new ThreadLocal<>(); 
threadLocalVariable.set("Value");

The Executor framework provides a higher-level replacement for managing threads. It decouples the task creation and execution, allowing better control over thread management.

Example:

Executor executor = Executors.newFixedThreadPool(3); 
executor.execute(() -> { /* Task logic */ });

The notify() method is used to wake up a single thread that is waiting on an object's monitor. It is part of the wait-notify mechanism for inter-thread communication.

Example:

synchronized (sharedObject) { 
sharedObject.notify(); 
}

ConcurrentHashMap is designed for multithreaded access and allows concurrent reads without blocking, while HashMap is not thread-safe and may lead to inconsistencies in a multithreaded environment.

Example:

ConcurrentMap concurrentMap = new ConcurrentHashMap<>();

AtomicInteger is a class in Java that provides atomic operations for integer variables, ensuring that operations on the variable are performed atomically without interference from other threads.

Example:

AtomicInteger counter = new AtomicInteger(0); counter.incrementAndGet();

Thread starvation occurs when a thread is unable to gain access to a resource or the CPU, preventing it from making progress. It is often caused by improper synchronization or priority mismanagement.

Example:

When low-priority threads continuously preempt high-priority threads.

The ReadWriteLock interface provides a lock that allows multiple threads to read a resource simultaneously but only one thread to write to the resource at any given time.

Example:

ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

CompletableFuture is a class in Java that represents a promise to complete an asynchronous computation. It provides a flexible way to compose, combine, and manage asynchronous operations.

Example:

CompletableFuture.supplyAsync(() -> /* Asynchronous computation */ ).thenApply(result -> /* Process result */ );

Deadlock is a situation where two or more threads are blocked forever, waiting for each other to release the locks.

Example:

Thread 1 locks resource A and waits for resource B. Thread 2 locks resource B and waits for resource A.

The wait-notify mechanism is used for inter-thread communication, where one thread can signal the other that a certain condition has been met.

Example:

Using wait(), notify(), and notifyAll() methods in synchronized blocks.

The join() method is used to wait for a thread to die. It causes the current thread to pause execution until the specified thread completes its execution.

Example:

Thread anotherThread = new Thread(() -> { 
/* Thread logic */ }); 
anotherThread.start(); 
anotherThread.join();

A race condition occurs when two or more threads access shared data concurrently, and the final outcome depends on the order of execution.

Example:

When two threads increment a shared counter without proper synchronization.

The ReentrantLock class is a part of the java.util.concurrent package and provides a flexible locking mechanism with the ability to interrupt a thread that is waiting for the lock.

Example:

ReentrantLock lock = new ReentrantLock(); 
lock.lock(); 
try { /* Critical section */ } 
finally { lock.unlock(); }

The producer-consumer problem involves two types of threads: producers that produce data and consumers that consume the data. The challenge is to synchronize their activities.

Example:

Using a shared buffer and synchronization mechanisms to ensure proper communication between producers and consumers.

Thread dumping involves generating a snapshot of all the threads' current state and stack traces. It is useful for diagnosing performance or deadlock issues.

Example:

In Java, you can use tools like jstack or VisualVM to generate thread dumps.

The happens-before relationship is a partial ordering of memory operations in Java. It ensures that the result of one operation is visible to another, providing a consistent view of shared data among threads.

Example:

Using synchronized blocks establishes a happens-before relationship.

The Phaser class in Java provides a more flexible alternative to the CountDownLatch and CyclicBarrier for synchronizing threads. It supports dynamic registration of threads and phase advancement.

Example:

Phaser phaser = new Phaser(); 
phaser.register(); // Register the current thread

The Exchanger class provides a synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the exchange method, matches with a partner thread, and receives its partner's object on return.

Example:

Exchanger exchanger = new Exchanger<>();

The ForkJoinPool is a special-purpose ExecutorService designed for parallelizing divide-and-conquer algorithms. It is particularly useful for recursive tasks with multiple subtasks.

Example:

RecursiveTask and RecursiveAction are classes commonly used with ForkJoinPool.