Multithreading in VB.NET


Multithreading is new to VB developer, VB developer always wanted this feature in the language and its there in VB .NET.

One of the many great features in Windows 95 and Windows NT is multiple threads. The power of multithreaded programming requires responsible programming. It's up to you to ensure that the CPU switching between threads won't cause bad things to happen. For example, you might have data (such as a linked list) that can be accessed by more than one thread. Your code needs to ensure that a threads switch at the wrong moment won't leave your data in an inconsistent state. You prevent threads-switching problems by using synchronization objects.


One or more threads run in an AppDomain. An AppDomain is a runtime representation of a logical process within a physical process. A thread is the basic unit to which the operating system allocates processor time. Each AppDomain is started with a single thread, but can create additional threads from any of its threads.

Each thread maintains exception handlers, a scheduling priority, and a set of structures the system will use to save the thread context until it is scheduled. The thread context includes the thread's set of machine registers and stack, in the address space of the thread's process.

Operating systems that support preemptive multitasking create the effect of simultaneous execution of multiple threads from multiple processes. On a multiprocessor computer, some operating systems that are multi-processor aware can simultaneously execute as many threads as there are processors on the computer.

A multitasking operating system divides the available processor time among the processes or threads that need it. The system is designed for preemptive multitasking; it allocates a processor time slice to each thread it executes. The currently executing thread is suspended when its time slice elapses, allowing another thread to run. When the system switches from one thread to another, it saves the thread context of the preempted thread and restores the saved thread context of the next thread in the queue.


Synchronizing resource access between threads is a common problem when writing multithreaded applications. Having two or more threads simultaneously access the same data can lead to undesirable and unpredictable results. For example, one thread could be updating the contents of a structure while another thread is reading the contents of the same structure. It is unknown what data the reading thread will receive: the old data, the newly written data, or possibly a mixture of both. .NET provides a number of synchronization and synchronization access classes to aid in solving this problem. 

This article explains the Monitor class available and how to use them to create thread-safe classes in a typical multithreaded application.


  • Monitors are associated with an object on demand.
  • Monitors are unbound i.e. can be called directly from any Context. 
  • Monitors cannot be instantiated; they are associated with an object.
Monitors expose the ability to take and release the sync block lock on an object on demand via Enter, TryEnter and Exit. The Monitor Wait, Pulse and PulseAll methods are related to SyncBlocks. It is necessary to be in a synchronized region on an object before calling Wait or Pulse on that object. Wait releases the lock if it is held and waits to be notified. When Wait is notified, it returns and has obtained the lock again. Notify signals for next thread in wait queue to proceed.

Monitor.Wait(b, 1000)
. . . ' do some work

How to run?

This is a console application, which demonstrates the Multithreading capability of .NET in Visual Basic.

This is a banking application which demonstrate the use of synchronization, to see why synchronization is necessary comment the Monitor.Enter(Me) and Monitor.Exit(Me), the result will vary and u will get the feel why synchronization is needed.

Up Next
    Ebook Download
    View all
    View all