多线程技术基于VB．NET的实现

多线程技术是实现需要并发执行的应用程序的较好选择,具有不可替代的作用。文中介绍了进程、线程以及应用程序域的概念及其相互之间的关系,讨论了VisualBasic.NET对多线程的支持。并从线程的创建与管理、线程取消、线程的优先级、线程的状态、线程池、线程的同步等方面展示了如何使用多线程编程技术来创建多线程应用程序。每个线程都需要资源,创建的线程过多,反而会降低应用程序的性能。在设计多线程应用程序时,应慎重对待,建立合理的系统模型,才能使应用程序获得最佳的性能。     

多线程技术基于VB.NET的实现

多线程技术是实现需要并发执行的应用程序的较好选择,具有不可替代的作用.文中介绍了进程、线程以及应用程序域的概念及其相互之间的关系,讨论了Visual Basic.NET对多线程的支持.并从线程的创建与管理、线程取消、线程的优先级、线程的状态、线程池、线程的同步等方面展示了如何使用多线程编程技术来创建多线程应用程序.每个线程都需要资源,创建的线程过多,反而会降低应用程序的性能.在设计多线程应用程序时,应慎重对待,建立合理的系统模型,才能使应用程序获得最佳的性能.     

多线程环境的高效内存分配技术

介绍了一种新的多线程内存分配技术（NIXMalloc）的设计和实现,提出了两种高效的分配策略及其自适应调优方法,有效地提高多线程应用程序的内存管理性能;其中Local分配策略对超级块对象Span进行了线程私有化,基于超级块对象为单位的垃圾回收和内存布局调整使多线程性能更优越;Global分配策略采用了自适应调优方法,在动态检测应用程序内存使用情况的基础上进行内存预取和线程缓存限值的动态调整;实验证明NIXMalloc可改善内存管理性能,提高吞吐量,同时降低内存使用量;在多线程应用系统中能获得较好的时空效率。     

Prophet推测多线程系统设计与实现

推测多线程技术通过推测执行的方式开发应用程序的线程级并行性,以提高程序执行性能。该技术一般通过执行模型来检测运行时可能的线程推测错误情况,并采取合适的机制恢复程序正确运行。描述的Prophet是一种基于硬件实现的推测多线程执行模型。重点描述了Prophet执行模型针对执行模型设计的关键问题的解决方案,包括Prophet的线程状态控制和多版本的Cach。系统,Prophet的多版本Cache系统提供了推测数据缓存功能,并使用基于总线监听的Cache协议实现了数据依赖违规检测。还给出了使用Olden基准程序对Prophet执行模型进行功能和性能测试的结果,并分析说明了Prophet系统可以有效地开发应用程序的线程级并行性。     

一种分布式共享存储系统的线程分配算法

讨论了软件实现了多线程ＤＳＭ 的通信开销和线程分配问题,给出了一种基于线程关系图的调度模型,并在此基础上提出了一种基于迭代的线程分配算法,通过大量的线程关系图对算法进行了评价,并且在一个软件ＤＳＭ系统中实现了该算法,同时给出了算法的评价结果和应用程序的性能数据。     

Java线程迁移机制的研究

从计算机集群系统实际应用出发,首先对Java线程的状态进行了分析,介绍了目前Java线程迁移机制的几种实现方法：处理源代码、处理字节码和扩展Java虚拟机的实现机制.从3个不同的方面进行了性能分析和比较,得出一个初步的评估.最后提出了一种扩展Java虚拟机方法的改进以及该迁移技术在集群系统中的应用.     

基于嵌入式Linux系统的内核级线程库的研究与实现

在当前嵌入式系统应用中,性能问题一直是人们关注的重点.大多数嵌入式Linux应用往往运行在用户态,系统运行时需要经常在内核态和用户态之间反复切换,降低了关键业务的执行效率.以往的研究较少从内核态下的线程库出发来考虑性能优化的实现方法,影响了嵌入式系统的整体性能.对此,本文提出一种适用于嵌入式Linux系统的内核级线程库(LKTL),并且分析了实现的关键技术.LKTL提供了线程管理、信号量同步、内存的动态分配和回收、日志管理以及基本的GNU C库的功能,不但大大提高了应用程序的运行效率,还方便了应用程序的开发和移植.实验表明LKTL能够显著优化嵌入式Linux系统的整体性能.     

实时CORBA线程研究与实现

近年来实时CORBA的在金融、电信、保险、医疗、制造业等行业发挥着越来越重要的作用,开发基于实时CORBA的应用程序,提高系统端对端的预测能力,使系统具有可靠健壮的性能.首先论述了实时CORBA体系结构与线程控制机制,对实时CORBA的ORB、POA与线程控制机制关系、实时CORBA线程的实现方式、线程的管理策略作了分析讨论,在这基础上讨论了建立实时系统的应用实例,将CORBA优先映射为本地优先,提供了灵活的线程管理机制,有效防止了线程的优先级翻转.     

基于VB.NET的多线程技术应用

采用多线程技术可充分提高应用程序运行效率,微软的.NET框架提供了新的线程类库,从而可以方便地创建多线程应用程序。本文首先简述了多线程应用的意义,介绍了进程、线程以及应用程序域的相互关系,随后举例介绍了使用Visual Basic.NET进行线程的创建与管理的过程,通过对Thread基类的引用可创建一个线程,然后可利用线程的start等方法属性进行线程的管理,并强调了线程的同步技术的应用,通过多线程编程技术的应用来开发效率更高、响应速度更快的应用程序。     

一组多线程的GUI教学演示程序

线程的概念是进程的延伸和发展,在面向对象应用程序的开发中,将某些类定义成线程并对其进行控制,会使应用程序取得特殊的执行效果。本文以使用Ｄｅｌｐｈｉ５．０建立一组线程控制的ＧＵＩ教学演示程序为例。说明线程在这类应用程序中的特殊应用以及这类应用程序的具体实现过程。     

Java 虚拟机用户级多线程的设计与实现

详细介绍了国产开放系统平台Java虚拟机多线程的设计与实现.在线程调度上,采用带有独立队列的静态级别轮巡调度,较好地解决了独立循环线程的调度问题.对于线程的同步,采用了哈希混合锁的设计方案.实验结果证明,该锁具有空间小、执行效率高等特点.     

现代操作系统中的进程、线程及在Windows OS下的应用

讲述了操作系统中进程、线程的概念 ,进程、线程间的关系 ,引进线程的好处 ,线程间的同步 ,以及进程、线程在Windows操作系统下的应用     

通用线程库的设计与实现

随着采集、处理、解释一体化地震勘探软件的发展,构建跨硬件、操作系统的云计算平台成为必要;而云计算平台中,通用线程库成为开发有大计算量算法的地震勘探软件的关键.通过对线程模型和同步机制的分析,分类整理出线程的属性、线程的控制、线程执行流的构建和同步的属性及操作;最后在这些通用的组件基础上,通过对各种本地线程库的封装,实现基于任意本地线程库的跨平台通用线程库.     

JAC技术实现生产者-消费者问题

JAC技术通过扩展JAVA注释实现并发，具有并发表达层次高、并发逻辑与应用逻辑分离、软件复用进一步加强等优点。论文利用JAC技术解决生产者-消费者问题，阐述了JAC技术的使用及其线程同步能力。     

Thread prioritization: A thread scheduling mechanism for multiple-context parallel processors

Multiple-context processors provide register resources that allow rapid context switching between several threads as a means of tolerating long communication and synchronization latencies. When scheduling threads on such a processor, we must first decide which threads should have their state loaded into the multiple contexts, and second, which loaded thread is to execute instructions at any given time. In this paper we show that both decisions are important, and that incorrect choices can lead to serious performance degradation. We propose thread prioritization as a means of guiding both levels of scheduling. Each thread has a priority that can change dynamically, and that the scheduler uses to allocate as many computation resources as possible to critical threads. We briefly describe its implementation, and we show simulation performance results for a number of simple benchmarks in which synchronization performance is critical.     

飞行颤振数据处理软件多线程编程的有效实现

多线程编程提高了飞行颤振数据处理软件的灵活性和易操作性，但也增加了软件编程和维护的复杂程度。针对这一矛盾，本文引进新的设计思想，提出新的多线程编程框图实现方法（Diagram method for multiple thread programming,DM/MTP），从而简化多线程的设计思路，特别适合于大型工程软件的设计。文中详细介绍了DM／MTP在模态参数识别算法NLUP中的应用。     

Parallel and distributed computing models on a graphics processing unit to accelerate simulation of membrane systems

Membrane systems are parallel distributed computing models that are used in a wide variety of areas. Use of a sequential machine to simulate membrane systems loses the advantage of parallelism in Membrane Computing. In this paper, an innovative classification algorithm based on a weighted network is introduced. Two new algorithms have been proposed for simulating membrane systems models on a Graphics Processing Unit (GPU). Communication and synchronization between threads and thread blocks in a GPU are time-consuming processes. In previous studies, dependent objects were assigned to different threads. This increases the need for communication between threads, and as a result, performance decreases. In previous studies, dependent membranes have also been assigned to different thread blocks, requiring inter-block communications and decreasing performance. The speedup of the proposed algorithm on a GPU that classifies dependent objects using a sequential approach, for example with 512 objects per membrane, was 82×, while for the previous approach (Algorithm 1), it was 8.2×. For a membrane system with high dependency among membranes, the speedup of the second proposed algorithm (Algorithm 3) was 12×, while for the previous approach (Algorithm 1) and the first proposed algorithm (Algorithm 2) that assign each membrane to one thread block, it was 1.8×.     

Prefetching with Helper Threads for Loosely Coupled Multiprocessor Systems

This paper presents a helper thread prefetching scheme that is designed to work on loosely coupled processors, such as in a standard chip multiprocessor (CMP) system or an intelligent memory system. Loosely coupled processors have an advantage in that resources such as processor and L1 cache resources are not contended by the application and helper threads, hence preserving the speed of the application. However, interprocessor communication is expensive in such a system. We present techniques to alleviate this. Our approach exploits large loop-based code regions and is based on a new synchronization mechanism between the application and helper threads. This mechanism precisely controls how far ahead the execution of the helper thread can be with respect to the application thread. We found that this is important in ensuring prefetching timeliness and avoiding cache pollution. To demonstrate that prefetching in a loosely coupled system can be done effectively, we evaluate our prefetching by simulating a standard unmodified CMP system and an intelligent memory system where a simple processor in memory executes the helper thread. Evaluating our scheme with nine memory-intensive applications with the memory processor in DRAM achieves an average speedup of 1.25. Moreover, our scheme works well in combination with a conventional processor-side sequential L1 prefetcher, resulting in an average speedup of 1.31. In a standard CMP, the scheme achieves an average speedup of 1.33. Using a real CMP system with a shared L2 cache between two cores, our helper thread prefetching plus hardware L2 prefetching achieves an average speedup of 1.15 over the hardware L2 prefetching for the subset of applications with high L2 cache misses per cycle.     

Generation, Optimization, and Evaluation of Multithreaded Code

The recent advent of multithreaded architectures holds many promises: the exploitation of intrathread locality and the latency tolerance of multithreaded synchronization can result in a more efficient processor utilization and higher scalability. The challenge for a code generation scheme is to make effective use of the underlying hardware by generating large threads with a large degree of internal locality without limiting the program level parallelism or increasing latency. Top-down code generation, where threads are created directly from the compiler's intermediate form, is effective at creating a relatively large thread. However, having only a limited view of the code at any one time limits the quality of threads generated. These top-down generated threads can therefore be optimized by global, bottom-up optimization techniques. In this paper, we introduce the Pebbles multithreaded model of computation and analyze a code generation scheme whereby top-down code generation is combined with bottom-up optimizations. We evaluate the effectiveness of this scheme in terms of overall performance and specific thread characteristics such as size, length, instruction level parallelism, number of inputs, and synchronization costs.