|
Windows Programming Interview Questions and Answers
What is Synchronization Objects?
Synchronization object s are use to co-ordinate the
execution of multiple threads. Which kernel objects are
use for Thread Synchronization on different processes? -
Event, Mutex, Semaphore
What is Event Object and why it is used?
Event is the thread synchronization object to set
signaled state or non-signaled state.
What is signaled and non signaled state?
An event is in signaled state means that it has the
capacity to release the threads waiting for this event
to be signaled. An event is in non signaled state means
that it will not release any thread that is waiting for
this particular event.example in our project: when user
clicks the image application icon double simultaneously.
Two image application windows were created. so PAIG
created an event and set it to non-signaled state. Then
the image application will reset the event to signaled
state, after this all the threads are released.
APIs for creating event and set and reset the events
CreateEvent- to create the event
OpenEvent - to open already created event
SetEvent - to set the event signaled state
RestEvent - To set the Event To non-Signaled State
What is Mutex Object and why it is used?
A mutex object is a synchronization object whose state
is set to signaled when it is not owned by any thread,
and non-signaled when it is owned. For example, to
prevent two threads from writing to shared memory at the
same time, each thread waits for ownership of a mutex
object before executing the code that accesses the
memory. After writing to the shared memory, the thread
releases the mutex object.
How do I create a Mutex?
A thread uses the CreateMutex function to create a mutex
object. The creating thread can request immediate
ownership of the mutex object and can also specify a
name for the mutex object
How do other threads own the mutex?
Threads in other processes can open a handle to an
existing named mutex object by specifying its name in a
call to theOpenMutex - function. Any thread with a
handle to a mutex object can use one of the wait
functions to request ownership of the mutex object. If
the mutex object is owned by another thread, the wait
function blocks the requesting thread until the owning
thread releases the mutex object using theReleaseMutex -
function.
How do other threads own the mutex?
A semaphore object is a synchronization object that
maintains a count between zero and a specified maximum
value. The count is decremented each time a thread
completes a wait for the semaphore object and
incremented each time a thread releases the semaphore.
When the count reaches zero, no more threads can
successfully wait for the semaphore object state to
become signaled. The state of a semaphore is set to
signaled when its count is greater than zero, and
non-signaled when its count is zero. The semaphore
object is useful in controlling a shared resource that
can support a limited number of users. It acts as a gate
that limits the number of threads sharing the resource
to a specified maximum number. For example, an
application might place a limit on the number of windows
that it creates. It uses a semaphore with a maximum
count equal to the window limit, decrementing the count
whenever a window is created and incrementing it
whenever a window is closed. The application specifies
the semaphore object in call to one of the wait
functions before each window is created. When the count
is zero - indicating that the window limit has been
reached - the wait function blocks execution of the
window-creation code.
Page Numbers
:
1
2
3
Have a Question ?
post your questions here. It
will be answered as soon as possible.
Check
HTML Interview
Questions for more HTML Interview Questions with Answers
Check
Job Interview Questions
for more Interview Questions with Answers
|
