Multithreading

Hi, welcome to this little tuturial on Win32 multithreading in Visual Basic.

For more mutithreading examples download the .zip file which includes a full sample project and my clsThreading.cls which makes multithreading much easier.

This tutorial is also included in the .zip file so you don´t have to read it here.

1. What is multitasking?

On Windows, as it is a 32 bit operating system, more then one task can run at once. Everybody knows that, you can e.g. run Paint and Windows Notepad at the same time.

You can switch between these tasks using the buttons in the taskbar.Well, they do not really run at the same time, because only one app can control the CPU at once, but Windows switches the processor control between these apps very fast, so that it seems that they are running at the same time.

This ability of Windows to handle various tasks at once is called multitasking.

2. What is multithreading?

But Windows can do even more.

Not only various tasks can run at once, but one task can create multiple threads, where every thread has its own function. For example, Windows Explorer can copy a huge file (with the file copy dialog) and, at the same time, you can still use the TreeView to navigate through the folders. A normal Visual Basic app is disabled until a task is finished (e.g. open a big file). In a multithreaded program, you can also click the titlebar and this won´t stop the program´s activities.

The ability of Windows to allow one app to handle multiple threads is called multithreading.

3. How can I implement multithreading in my VB program?

To use the cool multithreading in your VB app, you need some API calls (or my clsThreading.cls which is included in the .zip file) :

The first and most important is the CreateThread call :

Declare Function CreateThread Lib "kernel32" (ByVal lpThreadAttributes As Any, ByVal dwStackSize As Long, ByVal lpStartAddress As Long, lpParameter As Any, ByVal dwCreationFlags As Long, lpThreadID As Long) As Long

What it does? It creates a new thread in your app. Parameters :

• ByVal lpThreadAttributes As Any: The security attributes for the threads. The normal type is SECURITY_ATTRIBUTES, but you don´t need this parameter so use ByVal 0& as value.

• ByVal dwStackSize As Long: Tells Windows how much stack memory the thread should have. We don´t need it, use ByVal 0& for this parameter.

• ByVal lpStartAddress As Long: This is the most important parameter. It tells Windows which function the thread has to execute. To use this parameter, we need the AddressOf operator which can be used with public functions in public modules only. So place your threaded function in a module and for the lpStartAddress parameter use AddressOf YourFunction.

• ByVal dwCreationFlags As Long: The creation flags for the thread. To use this parameter, search the CREATE_* constants in the API Viewer (they are also in clsThreading.cls). One interesting flag is the CREATE_SUSPENDED flag, which allows you to create the thread disabled (not running). If you don´t need this parameter, use ByVal 0&.

• lpThreadID As Long: This is a ByRef parameter which represents the ID of the created thread.

The return value of the CreateThread function is the handle to the created thread. A handle to a thread is like a Window handle (hWnd). It allows you to take control over the thread. If the CreateThread function returns 0, it failed to create the thread.

The next important API call is SetThreadPriority :

Declare Function SetThreadPriority Lib "kernel32" (ByVal hThread As Long, ByVal nPriority As Long) As Long

It sets the priority of a specified thread. Parameters :

• ByVal hThread As Long: The handle to the thread. You can use for example the return value of the CreateThread call.

• ByVal nPriority As Long: The new priority of the specified thread. The thread priority has five major values: THREAD_PRIORITY_LOWEST, THREAD_PRIORITY_BELOW_NORMAL, THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_ABOVE_NORMAL and THREAD_PRIORITY_HIGHEST which should be self-explaining. The constants for these values can be found in the API viewer (and in clsThreading.cls).

To get the actual priority of a thread use the GetThreadPriority call.

There are two more interesting threading calls, SuspendThread and ResumeThread :

Declare Function SuspendThread Lib "kernel32" (ByVal hThread As Long) As Long

Declare Function ResumeThread Lib "kernel32" (ByVal hThread As Long) As Long

SuspendThread disables a thread and ResumeThread enables a disabled thread. Parameters :

• ByVal hThread As Long: The handle to the thread we want to disable/enable.

The last call, TerminateThread fully stops a thread. It is important that you stop all threads this way before closing your application because otherwise, it might crash.

Declare Function TerminateThread Lib "kernel32" (ByVal hThread As Long, ByVal dwExitCode As Long) As Long

Parameters :

• ByVal hThread As Long: We know it: The handle to the thread we want to terminate.

• ByVal dwExitCode As Long: An exit code (not needed). Use ByVal 0& for this parameter.

4. Thank you

Thank you for reading this tutorial. Now you know the most common Win32 multithreading calls, you can create, stop, enable, disable threads and you can change the priority of threads. Did you learn something? If yes, please vote for me. And excuse me for my bad english because I´m german.

Philipp Weidmann