Definitions; Multithreading Interview Questions;
Multithreading FAQ
Process and Threads
A process is a collection of virtual memory space, code,
data, and system resources. A thread is code that is to be serially executed
within a process.
Process always has at least one thread of execution, known
as the primary thread. A process can have multiple threads in addition to the
primary thread.
Threads vs. Processes
Both threads and processes and they are time sliced with
other threads and processes. The key differences are
1. All threads within a single application are logically
contained within a process.
2. Processes are fully isolated from each other but threads
share the heap memory with other threads running in the same
process\application.
Foreground and Background Threads
1. Foreground threads keep the application alive. But
background threads do not keep the application alive on their own. They
terminate immediately once all foreground threads have ended.
2. By default threads are foreground threads. Thread can be
set as background thread. (thread.IsBackground = true; )
Deadlock Condition
A deadlock occurs when each thread is waiting for the other
to do something A race condition occurs when one thread finishes before another
on which it depends, causing the former to use a bogus value because the latter
has not yet supplied a valid one.
Race Condition
A race condition exists when a thread modifies a resource to
an invalid state, and then another thread attempts to access that resource and
use it in the invalid state
Synchronizing objects
Lock
Locks are useful when only one thread at a time can be
allowed to modify data or some other controlled resource.
Monitors
Monitors are Like the lock keyword, monitors prevent blocks
of code from simultaneous execution by multiple threads. The Enter method
allows one and only one thread to proceed into the following statements; all
other threads are blocked until the executing thread calls Exit. This is just
like using the lock keyword. In fact, the lock keyword is implemented with the
Monitor class.
Mutex
A mutex is similar to a monitor; it prevents the
simultaneous execution of a block of code by more than one thread at a time. In
fact, the name "mutex" is a shortened form of the term "mutually
exclusive." Unlike monitors, however, a mutex can be used to synchronize
threads across processes.
Semaphore is same as Mutex but it ensures not more than a
specified number of threads can access a resource, or section of code.
Double-check locking for Signleton classes.
More at Multithreaded Singleton: Double-check locking
public sealed class Singleton
{
private static
volatile Singleton instance;
private static
object syncRoot = new Object();
public static
Singleton Instance {
get {
if
(instance == null) {
lock
(syncRoot) {
if
(instance == null)
instance = new Singleton();
}
}
return
instance;
}
}
}
Apartments
COM objects in the process as divided into groups called
apartments. A COM object lives in exactly one apartment, in the sense that its
methods can legally be directly called only by a thread that belongs to that
apartment. Any other thread that wants to call the object must go through a
proxy.
There are two types of apartments: single-threaded
apartments, and multithreaded apartments.
1.Single-threaded Apartments—Single-threaded apartments
consist of exactly one thread, so all COM objects that live in a single-threaded
apartment can receive method calls only from the one thread that belongs to
that apartment. All method calls to a COM object in a single-threaded apartment
are synchronized with the windows message queue for the single-threaded
apartment's thread. A process with a single thread of execution is simply a
special case of this model.
2. Multithreaded Apartments—Multithreaded apartments consist
of one or more threads, so all COM objects that live in an multithreaded
apartment can receive method calls directly from any of the threads that belong
to the multithreaded apartment. Threads in a multithreaded apartment use a
model called free-threading. Calls to COM objects in a multithreaded apartment
are synchronized by the objects themselves.
No comments:
Post a Comment