MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Visual Basic多线程编程基础与同步机制

2021-10-261.8k 阅读

Visual Basic多线程编程基础

多线程概念简述

在计算机编程领域，线程是进程中的一个执行单元。一个进程可以包含多个线程，这些线程共享进程的资源，如内存空间、文件描述符等。多线程编程允许程序同时执行多个任务，提高了程序的响应性和资源利用率。例如，在一个图形用户界面（GUI）应用程序中，主线程通常负责处理用户界面的绘制和事件响应。如果在主线程中执行一个耗时的操作，如文件读取或网络请求，界面将会冻结，用户无法进行交互。通过使用多线程，我们可以将这些耗时操作放在单独的线程中执行，主线程仍然可以及时响应用户的操作，从而提升用户体验。

Visual Basic线程模型基础

在Visual Basic中，从早期版本开始对多线程编程的支持相对有限，但随着版本的发展，逐渐提供了更完善的机制。Visual Basic的线程模型基于Windows操作系统的线程机制。Windows采用抢占式多任务处理，这意味着操作系统可以在不同线程之间动态分配CPU时间片。在Visual Basic中创建线程，我们需要了解一些关键的类和方法。

例如，在较新的Visual Basic版本中，可以使用System.Threading.Thread类来创建和管理线程。以下是一个简单的创建线程的示例代码：

Imports System.Threading

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread As New Thread(AddressOf MyThreadFunction)
        myThread.Start()
    End Sub

    Private Sub MyThreadFunction()
        '这里是线程执行的代码
        For i As Integer = 1 To 10
            Console.WriteLine("线程执行: " & i)
            Thread.Sleep(1000)'线程暂停1秒
        Next
    End Sub
End Class

在上述代码中，我们首先引入了System.Threading命名空间，这是使用线程相关功能所必需的。在Button1_Click事件中，我们创建了一个新的Thread对象，构造函数的参数是一个指向MyThreadFunction方法的委托，这个方法将在线程启动后执行。然后调用myThread.Start()方法启动线程。MyThreadFunction方法简单地在控制台输出一些信息，并每隔1秒暂停一次线程。

线程生命周期

  1. 新建状态（New）：当使用New关键字创建一个Thread对象时，线程处于新建状态。此时线程还没有开始执行，例如在上述代码中Dim myThread As New Thread(AddressOf MyThreadFunction)这一步，myThread线程对象就处于新建状态。
  2. 就绪状态（Ready）：调用Start方法后，线程进入就绪状态。在这个状态下，线程已经准备好执行，但还没有分配到CPU时间片，等待操作系统调度。如myThread.Start()执行后，myThread线程进入就绪状态。
  3. 运行状态（Running）：当操作系统为线程分配了CPU时间片，线程进入运行状态，开始执行ThreadStart委托所指向的方法代码，即MyThreadFunction中的代码开始执行。
  4. 阻塞状态（Blocked）：线程在执行过程中可能会因为某些原因进入阻塞状态，暂时停止执行。例如，当调用Thread.Sleep方法时，线程会进入阻塞状态，直到指定的时间过去。在上述代码中Thread.Sleep(1000)会使线程暂停1秒，这1秒内线程处于阻塞状态。另外，当线程等待获取一个锁（后面会详细介绍同步机制中的锁），或者进行I/O操作（如文件读取、网络请求）时，也会进入阻塞状态。
  5. 死亡状态（Dead）：当线程的执行方法（如MyThreadFunction）执行完毕，或者调用Abort方法强制终止线程时，线程进入死亡状态，此时线程的生命周期结束，不能再重新启动。

Visual Basic多线程同步机制

同步问题引入

在多线程编程中，当多个线程同时访问共享资源时，可能会出现数据不一致或其他问题。例如，假设有两个线程同时对一个共享的整数变量进行递增操作。正常情况下，递增操作可以分解为读取变量值、增加1、写回变量值这三个步骤。如果没有适当的同步机制，可能会出现以下情况：

线程1读取变量值为10，此时线程2也读取变量值为10（因为线程1还没有来得及写回）。然后线程1增加1并写回，变量值变为11。接着线程2也增加1并写回，变量值仍然是11，而不是预期的12。这种情况就称为竞态条件（Race Condition），会导致程序出现难以调试的错误。

锁机制（Mutex和Monitor）

  1. Mutex（互斥锁）：Mutex（互斥体）是一种同步工具，它只允许一个线程进入临界区（共享资源访问区域）。在Visual Basic中，可以使用System.Threading.Mutex类。以下是一个使用Mutex的示例：
Imports System.Threading

Public Class Form1
    Private Shared count As Integer = 0
    Private Shared myMutex As New Mutex()

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread1 As New Thread(AddressOf IncrementCount)
        Dim myThread2 As New Thread(AddressOf IncrementCount)
        myThread1.Start()
        myThread2.Start()
        myThread1.Join()
        myThread2.Join()
        Console.WriteLine("最终计数: " & count)
    End Sub

    Private Sub IncrementCount()
        myMutex.WaitOne()'等待获取Mutex
        Try
            For i As Integer = 1 To 1000
                count = count + 1
            Next
        Finally
            myMutex.ReleaseMutex()'释放Mutex
        End Try
    End Sub
End Class

在上述代码中，我们定义了一个共享变量count，并创建了一个Mutex对象myMutex。在IncrementCount方法中，首先调用myMutex.WaitOne()等待获取Mutex，如果Mutex已经被其他线程持有，当前线程会进入阻塞状态。只有获取到Mutex后，线程才能进入临界区执行对count的递增操作。操作完成后，通过myMutex.ReleaseMutex()释放Mutex，允许其他线程获取。

  1. Monitor：Monitor类提供了更灵活的同步控制。它的功能与Mutex类似，但可以实现更复杂的同步逻辑。以下是使用Monitor的示例：
Imports System.Threading

Public Class Form1
    Private Shared count As Integer = 0
    Private Shared lockObject As New Object()

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread1 As New Thread(AddressOf IncrementCount)
        Dim myThread2 As New Thread(AddressOf IncrementCount)
        myThread1.Start()
        myThread2.Start()
        myThread1.Join()
        myThread2.Join()
        Console.WriteLine("最终计数: " & count)
    End Sub

    Private Sub IncrementCount()
        Monitor.Enter(lockObject)'进入临界区
        Try
            For i As Integer = 1 To 1000
                count = count + 1
            Next
        Finally
            Monitor.Exit(lockObject)'离开临界区
        End Try
    End Sub
End Class

这里我们创建了一个普通的Object对象lockObject作为锁对象。在IncrementCount方法中，通过Monitor.Enter(lockObject)进入临界区，只有获取到锁（即其他线程没有持有该锁）才能进入。执行完临界区代码后，通过Monitor.Exit(lockObject)释放锁。

信号量（Semaphore）

信号量是一种更通用的同步机制，它允许多个线程同时进入临界区，但有一定的数量限制。在Visual Basic中，可以使用System.Threading.Semaphore类。例如，假设我们有一个资源池，最多允许3个线程同时访问：

Imports System.Threading

Public Class Form1
    Private Shared semaphore As New Semaphore(3, 3)'初始和最大并发数都为3

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        For i As Integer = 1 To 5
            Dim myThread As New Thread(AddressOf UseResource)
            myThread.Start(i)
        Next
    End Sub

    Private Sub UseResource(ByVal threadId As Object)
        semaphore.WaitOne()'等待获取信号量
        Try
            Console.WriteLine("线程 " & threadId & " 进入资源区")
            Thread.Sleep(2000)'模拟使用资源
            Console.WriteLine("线程 " & threadId & " 离开资源区")
        Finally
            semaphore.Release()'释放信号量
        End Try
    End Sub
End Class

在上述代码中，我们创建了一个Semaphore对象semaphore，初始和最大并发数都设置为3。在UseResource方法中，线程首先调用semaphore.WaitOne()等待获取信号量。如果当前允许进入的线程数未达到上限，线程可以获取信号量并进入临界区。执行完操作后，通过semaphore.Release()释放信号量，允许其他线程获取。

读写锁（ReaderWriterLockSlim）

当共享资源的读取操作远远多于写入操作时，使用读写锁可以提高性能。ReaderWriterLockSlim类提供了读写锁功能。读操作可以并发执行，而写操作需要独占访问。以下是一个示例：

Imports System.Threading

Public Class Form1
    Private Shared data As Integer = 0
    Private Shared rwLock As New ReaderWriterLockSlim()

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim readThread1 As New Thread(AddressOf ReadData)
        Dim readThread2 As New Thread(AddressOf ReadData)
        Dim writeThread As New Thread(AddressOf WriteData)
        readThread1.Start()
        readThread2.Start()
        writeThread.Start()
        readThread1.Join()
        readThread2.Join()
        writeThread.Join()
        Console.WriteLine("最终数据: " & data)
    End Sub

    Private Sub ReadData()
        rwLock.EnterReadLock()'进入读锁
        Try
            Console.WriteLine("读取数据: " & data)
        Finally
            rwLock.ExitReadLock()'离开读锁
        End Try
    End Sub

    Private Sub WriteData()
        rwLock.EnterWriteLock()'进入写锁
        Try
            data = data + 10
            Console.WriteLine("写入数据: " & data)
        Finally
            rwLock.ExitWriteLock()'离开写锁
        End Try
    End Sub
End Class

在上述代码中，ReadData方法使用rwLock.EnterReadLock()进入读锁，允许多个读线程同时执行。WriteData方法使用rwLock.EnterWriteLock()进入写锁，此时其他读写线程都不能进入，保证写操作的原子性。

多线程异常处理

线程内异常

在多线程编程中，线程内的异常处理有其特殊性。当一个线程抛出未处理的异常时，默认情况下，CLR（公共语言运行时）会终止整个进程。为了避免这种情况，我们需要在每个线程中进行适当的异常处理。例如，修改前面的线程函数：

Imports System.Threading

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread As New Thread(AddressOf MyThreadFunction)
        myThread.Start()
    End Sub

    Private Sub MyThreadFunction()
        Try
            For i As Integer = 1 To 10
                Console.WriteLine("线程执行: " & i)
                If i = 5 Then
                    Throw New Exception("模拟异常")
                End If
                Thread.Sleep(1000)
            Next
        Catch ex As Exception
            Console.WriteLine("线程内捕获到异常: " & ex.Message)
        End Try
    End Sub
End Class

在上述代码中，当i等于5时，线程抛出一个异常。通过在MyThreadFunction方法中使用Try - Catch块，我们可以捕获并处理这个异常，避免异常导致整个进程终止。

跨线程异常处理

在Visual Basic的Windows Forms应用程序中，如果一个工作线程需要更新UI，直接操作UI控件会引发跨线程操作异常。例如：

Imports System.Threading

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread As New Thread(AddressOf UpdateUI)
        myThread.Start()
    End Sub

    Private Sub UpdateUI()
        Label1.Text = "更新的文本" '这会引发跨线程操作异常
    End Sub
End Class

上述代码会引发异常，因为在工作线程中直接访问了UI控件Label1。为了解决这个问题，我们可以使用Invoke或BeginInvoke方法。Invoke方法是同步的，会阻塞调用线程直到UI线程处理完委托；BeginInvoke是异步的，不会阻塞调用线程。以下是使用BeginInvoke的示例：

Imports System.Threading

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread As New Thread(AddressOf UpdateUI)
        myThread.Start()
    End Sub

    Private Sub UpdateUI()
        Me.Invoke(Sub()
                      Label1.Text = "更新的文本"
                  End Sub)
    End Sub
End Class

在上述代码中，通过Me.Invoke方法，我们将更新UI的操作委托给UI线程执行，从而避免了跨线程操作异常。

多线程性能考量

线程创建与销毁开销

创建和销毁线程都有一定的开销。每次创建一个新线程，操作系统需要为其分配栈空间、线程上下文等资源。销毁线程时，也需要进行资源回收。因此，如果在程序中频繁地创建和销毁线程，会导致性能下降。例如，在一个循环中不断创建线程来执行短期任务，不如使用线程池来复用线程。

线程调度开销

操作系统在多个线程之间进行调度也会产生开销。当一个线程的时间片用完或者进入阻塞状态时，操作系统需要保存当前线程的上下文，然后切换到另一个线程，加载其上下文。这种上下文切换会消耗CPU时间。如果线程数量过多，上下文切换的频率会增加，从而降低整体性能。因此，在设计多线程程序时，需要合理控制线程数量，避免线程过度竞争CPU资源。

同步机制开销

同步机制如锁、信号量等虽然可以保证数据的一致性，但也会带来性能开销。例如，当一个线程获取锁时，如果锁已经被其他线程持有，当前线程会进入阻塞状态，这会导致线程上下文切换。而且，频繁地获取和释放锁也会消耗CPU时间。因此，在使用同步机制时，应该尽量缩小临界区的范围，减少锁的持有时间，以降低性能开销。

实际应用场景中的多线程编程

图形用户界面（GUI）应用

在GUI应用中，多线程常用于处理耗时操作，以避免界面冻结。例如，在一个文件压缩工具中，压缩文件是一个耗时操作。如果在主线程中执行压缩，用户在压缩过程中无法操作界面。通过将压缩操作放在一个单独的线程中，主线程可以继续响应用户的操作，如取消压缩、查看进度等。以下是一个简单的示例：

Imports System.Threading

Public Class Form1
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim myThread As New Thread(AddressOf CompressFile)
        myThread.Start()
    End Sub

    Private Sub CompressFile()
        '模拟文件压缩操作
        For i As Integer = 1 To 100
            '更新进度条等操作，需要通过Invoke或BeginInvoke
            Me.Invoke(Sub()
                          ProgressBar1.Value = i
                      End Sub)
            Thread.Sleep(100)'模拟压缩时间
        Next
        Me.Invoke(Sub()
                      MessageBox.Show("压缩完成")
                  End Sub)
    End Sub
End Class

在上述代码中，CompressFile方法模拟文件压缩操作，并通过Invoke方法更新UI控件ProgressBar1的进度值和显示压缩完成的消息框。

网络编程

在网络编程中，多线程可以提高程序的并发处理能力。例如，在一个服务器程序中，可能需要同时处理多个客户端的连接请求。每个客户端连接可以分配一个单独的线程来处理数据的接收和发送。这样，服务器可以同时与多个客户端进行交互，提高了服务器的性能和响应速度。以下是一个简单的TCP服务器示例：

Imports System.Net.Sockets
Imports System.Threading

Public Class Form1
    Private serverSocket As TcpListener
    Private isListening As Boolean = False

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        If Not isListening Then
            serverSocket = New TcpListener(IPAddress.Any, 12345)
            serverSocket.Start()
            isListening = True
            Dim listenThread As New Thread(AddressOf ListenForClients)
            listenThread.Start()
            Button1.Text = "停止监听"
        Else
            serverSocket.Stop()
            isListening = False
            Button1.Text = "开始监听"
        End If
    End Sub

    Private Sub ListenForClients()
        While isListening
            Dim clientSocket As TcpClient = serverSocket.AcceptTcpClient()
            Dim clientThread As New Thread(AddressOf HandleClient)
            clientThread.Start(clientSocket)
        End While
    End Sub

    Private Sub HandleClient(ByVal clientSocketObject As Object)
        Dim clientSocket As TcpClient = DirectCast(clientSocketObject, TcpClient)
        Dim networkStream As NetworkStream = clientSocket.GetStream()
        Dim buffer(1024) As Byte
        Dim bytesRead As Integer = networkStream.Read(buffer, 0, buffer.Length)
        Dim message As String = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead)
        Console.WriteLine("收到客户端消息: " & message)
        '处理消息并回复
        Dim responseMessage As String = "消息已收到"
        Dim responseBuffer() As Byte = System.Text.Encoding.UTF8.GetBytes(responseMessage)
        networkStream.Write(responseBuffer, 0, responseBuffer.Length)
        networkStream.Close()
        clientSocket.Close()
    End Sub
End Class

在上述代码中，ListenForClients方法在一个单独的线程中监听客户端连接请求。每当有新的客户端连接时，创建一个新线程HandleClient来处理该客户端的通信。HandleClient方法读取客户端发送的消息，处理后回复消息，然后关闭连接。

数据处理与计算密集型任务

在数据处理和计算密集型任务中，多线程可以利用多核CPU的优势，提高处理速度。例如，在一个图像渲染程序中，渲染一幅图像可以分成多个部分，每个部分由一个线程进行渲染，最后将各个部分的结果合并。以下是一个简单的计算密集型任务示例，计算1到1000000的累加和：

Imports System.Threading

Public Class Form1
    Private Shared total1 As Long = 0
    Private Shared total2 As Long = 0

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Dim thread1 As New Thread(AddressOf CalculateSum1)
        Dim thread2 As New Thread(AddressOf CalculateSum2)
        thread1.Start()
        thread2.Start()
        thread1.Join()
        thread2.Join()
        Dim total As Long = total1 + total2
        Console.WriteLine("累加和: " & total)
    End Sub

    Private Sub CalculateSum1()
        For i As Integer = 1 To 500000
            total1 = total1 + i
        Next
    End Sub

    Private Sub CalculateSum2()
        For i As Integer = 500001 To 1000000
            total2 = total2 + i
        Next
    End Sub
End Class

在上述代码中，将计算任务分成两个部分，分别由两个线程CalculateSum1和CalculateSum2执行，最后将两个部分的结果相加得到最终的累加和，从而提高计算效率。

通过以上对Visual Basic多线程编程基础与同步机制的介绍，以及实际应用场景的示例，希望能帮助开发者更好地掌握多线程编程技术，编写出高效、稳定的应用程序。在实际开发中，需要根据具体的需求和场景，合理运用多线程技术，并注意同步机制和性能优化，以充分发挥多线程编程的优势。