面试题与答案

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 */ );