"LabVIEW多线程：多任务处理的高级编程技术"

54 浏览量更新于2023-12-29 收藏 1.4MB PDF 举报

LabVIEW多线程是一个高级编程主题，它的使用需要程序员对这项技术有基本的了解。LabVIEW为程序员提供了两大优势：多任务和多线程。第一个优点是完全抽象线程本身。LabVIEW程序员从不创建、销毁或同步线程。第二个优势是LabVIEW使用的数据流模型。这个模型为G提供了与其文本语言对应物相比的明显优势，因为它简化了程序员对多任务处理的看法。多线程为软件工程增加了一个新的维度。应用程序可以同时执行多项任务。一个很好的应用示例添加了多线程的是Microsoft Word。Word使用多线程来执行拼写检查和语法验证。为执行此任务而添加的线程允许应用程序执行在用户打字时执行这些任务。以前的版本，Word 6.0 forWindows3.1，不能这样做，因为它一次只运行一个任务；用户必须停止键入并选择“检查拼写”。在LabVIEW中，多线程可以用于提高应用程序的性能。多线程的使用需要程序员对这项技术有基本的了解。LabVIEW提供了两大优势：多任务和多线程。第一个优点是完全抽象线程本身。LabVIEW程序员从不创建、销毁或同步线程。第二个优势是LabVIEW使用的数据流模型。随着多线程的引入，LabVIEW应用程序可以同时执行多项任务。这种高级编程技术需要程序员具有良好的基本了解。多线程可以提高应用程序的性能，这对于实时性要求高的应用程序尤为重要。因此，对于LabVIEW程序员来说，了解和掌握多线程技术是至关重要的。需要注意的是，多线程也带来了一些挑战。在多线程的环境下，程序的状态和数据可能会更加复杂，因此需要更加严密的程序设计和测试。同时，多线程的使用也需要更多的系统资源，因此需要在资源管理上进行更加谨慎的考虑。总而言之，多线程是一个复杂而强大的编程技术，它可以为LabVIEW应用程序带来明显的性能提升。然而，程序员需要具备基本的了解和技能才能正确、高效地使用多线程。因此，对于LabVIEW程序员来说，掌握多线程技术是至关重要的。LabVIEW的多线程模型为程序员提供了一个更加简化和抽象的方式来处理多任务，这对于提高程序的可维护性和可扩展性也具有重要意义。

system to determine if data protected by the mutex is in a transient state and would

cause problems if another thread were given control of the data.

A semaphore is similar to a mutex, but ownership is permitted by a speciﬁed

number of threads. An analogy of a semaphore is a crowded nightclub. If capacity

of the club is limited to 500 people, and 600 people want to enter the club, 100 are

forced to wait outside. The doorman is the semaphore, and restricts access to the

ﬁrst 500 people. When a person exits, another individual from outside is allowed to

enter. A semaphore works the same way.

Mutexes and semaphores must be used in DLLs and code libraries if they are

to be considered thread-safe. LabVIEW can be conﬁgured to call DLLs from the

user interface subsystem, its primary thread, if it is unclear that the DLL is thread

safe. A programmer should never assume that code is thread safe; this can lead to

very difﬁcult issues to resolve.

9.2 THREAD MECHANICS

All activities threads perform are documented in an operating system’s speciﬁcation.

The actual behavior of the threads is dependent on a vendor’s implementation. In

the case of Windows, there is only one vendor, Microsoft. On the other hand, UNIX

has a number of vendors who implement the standard in slightly different ways.

Providing detailed information on operating system-speciﬁc details for all the UNIX

ﬂavors is beyond the scope of this book.

Regardless of operating system, all threads have a few things in common. First,

threads must be given time on the CPU to execute. The operating system scheduler

determines which threads get time on the CPU. Second, all threads have a concept

of state; the state of a thread determines its eligibility to be given time on the CPU.

9.2.1 T

HREAD

TATES

A thread can be in one of three states: Active, Blocked, or Suspended. Active threads

will be arranged according to their priority and allocated time on the CPU. An active

thread may become blocked during its execution. In the event an executing thread

becomes blocked, it will be moved into the inactive queue, which will be explained

shortly.

Threads that are blocked are currently waiting on a resource from the operating

system (a Kernel object or message). For example, when a thread tries to access the

hard drive of the system, there will be a delay on the order of 10 ms for the hard

drive to respond. The operating system blocks this thread because it is now waiting

for a resource and would otherwise waste time on the CPU. When the hard drive

triggers an interrupt, it informs the operating system it is ready. The operating system

will signal the blocked thread and the thread will be put back into a run queue.

Suspended threads are “sleeping.” For example, in C, using the Sleep statement

will suspend the thread that executed the command. The operating system effectively

treats blocked and suspended threads in the same fashion; they are not allowed time

on the CPU. Both suspended and blocked threads are allowed to resume execution

when they have the ability to, when they are signaled.

9.2.2 S

CHEDULING

HREADS

The operation of a scheduling algorithm is not public knowledge for most operating

systems, or at least a vendor’s implementation of the scheduling algorithm. The

basic operation of scheduling algorithms is detailed in this section.

The operating system will maintain two lists of threads. The ﬁrst list contains

the active threads and the second list contains blocked and suspended threads. The

active thread list is time-ordered and weighted by the priority of the thread in the

system. The highest priority thread will be allowed to run on the CPU for a speciﬁed

amount of time, and will then be switched off the CPU. This is referred to as a

“Round Robin” scheduling policy.

When there are multiple CPUs available to the system, the scheduler will deter-

mine which threads get to run on which CPU. Symmetric Multiprocessing (SMP)

used in Windows NT allows for threads of the same process to run on different

CPUs. This is not always the case. A dual-CPU machine may have threads of

different processes running on the pair of CPUs, which is determined by the sched-

uling algorithm. Some UNIX implementations only allow a process’s threads on a

single CPU.

The blocked/suspended queue is not time-ordered. It is impossible for the oper-

ating system to know when a signal will be generated to unblock a thread. The

scheduling algorithm polls this list to determine if any threads have become available

to execute. When a thread becomes unblocked and has higher priority than the

currently running thread, it will be granted control of the CPU.

9.2.3 C

ONTEXT

WITCHING

The process of changing which thread is executing on the CPU is called “context

switching.” Context switching between threads that are in the same process is

relatively fast. This is referred to as a “thread context switch.” The CPU needs to

ofﬂoad the current thread’s instruction pointer and its copy of the CPU registers into

memory. The CPU will then load the next thread’s information and begin executing

the next thread. Since threads in the same process execute in the same protected

memory, there is no need to remap physical memory into the memory map used by

the process.

When context switching occurs between threads of different processes, it is

called a “process context switch.” There is a lot more work that is required in a

process context switch. In addition to swapping out instruction pointers and CPU

registers, the memory mapping must also be changed for the new thread.

As mentioned in Section 9.2.2, when a thread becomes signaled (eligible to run)

and has a higher priority than the currently running thread, it will be given control

of the CPU. This is an involuntary context switch. This is a potential problem for

LabVIEW programmers. Section 9.5 will discuss multithreading problems such as

starvation and priority inversion that can be caused by poorly-designed conﬁgura-

tions of LabVIEW’s thread pools. Conﬁguring the threads that LabVIEW uses is

discussed in Section 9.7.4.

剩余41页未读，继续阅读

LabVIEW开发

粉丝: 1w+

"LabVIEW多线程：多任务处理的高级编程技术"

同时运行多个LabVIEW exe实例

Using LabVIEW to Create Multithreaded Applications

Customize UI in a LabVIEW application

LabVIEW.rar_CAN_CAN labview_canbus labview_labview can_labview

can-labview-information.rar_CAN_CAN labview_Labview can_labview

can.rar_ labview can_CAN Bus labview_CAN labview_labview can总线_l

ss.rar_Labview can_labview can_labview 台架_labview can_台架

dianchiguanli.rar_CAN Bus labview_Labview can_labview can_labv

USB-RAW---CDC-test.zip_CAN_labview can_labview usb can_labview

LabVIEW Example(8.6).zip_CAN_labview can_labview汽车CAN_汽车CAN_纯电动

最新资源