threadx源代码学习
c++ 多线程 简单代码
以下是一个简单的C++多线程示例代码，展示了如何创建和运行多个线程：#include <iostream>#include <thread>// 线程函数void threadFunction(int threadID) {std::cout << "Thread " << threadID << " is running" << std::endl;}int main() {// 创建多个线程std::thread t1(threadFunction, 1);std::thread t2(threadFunction, 2);// 等待线程结束t1.join();t2.join();std::cout << "All threads have completed" << std::endl;return 0;}在这个示例中，我们包含了`<thread>`头文件以使用C++的多线程功能。
我们定义了一个`threadFunction`函数作为线程的入口点，然后在`main`函数中创建了两个线程`t1`和`t2`，并将`threadFunction`作为参数传递给它们。
最后，我们使用`join`函数等待线程的结束。
当你运行这个程序时，你会看到类似以下的输出：Thread 1 is runningThread 2 is runningAll threads have completed这个示例演示了如何在C++中使用多线程，并创建了两个线程来并行执行`threadFunction`函数。
JAVA_Thread源码分析
线程是程序的一个执行流程，Java虚拟机允许多个线程同时并发执行。
1. 构造方法Java代码1.public Thread() {2. init(null, null, "Thread-" + nextThreadNum(), 0);3.}4.5.// target - 任务6.public Thread(Runnable target) {7. init(null, target, "Thread-" + nextThreadNum(), 0);8.}9.10.// group - 线程组，target - 任务11.public Thread(ThreadGroup group, Runnable target) {12. init(group, target, "Thread-" + nextThreadNum(), 0);13.}14.15.// name - 线程名称16.public Thread(String name) {17. init(null, null, name, 0);18.}19.20.// group - 线程组，name - 线程名称21.public Thread(ThreadGroup group, String name) {22. init(group, null, name, 0);23.}24.25.// target - 任务，name - 线程名称26.public Thread(Runnable target, String name) {27. init(null, target, name, 0);28.}29.30.// group - 线程组，target - 任务，name - 线程名称31.public Thread(ThreadGroup group, Runnable target, String name) {32. init(group, target, name, 0);33.}34.35.// group - 线程组，target - 任务，name - 线程名称, stackSize - 栈大小36.// 这里的stackSize只是提供一个参考值，和平台相关，JVM根据情况会做适当的调整。
threadx
threadxThreadX是一种实时操作系统(RTOS)，具有小型、高效、可靠的特性，广泛应用于嵌入式系统的开发中。
本文将介绍ThreadX的基本概念和特征，以及它在嵌入式系统开发中的应用。
一、ThreadX的基本概念和特征ThreadX是一个多线程实时操作系统，意味着它能同时运行多个线程，并提供实时性能保证。
下面将介绍ThreadX的基本概念和特征。
1. 线程：ThreadX的核心是线程，线程是可独立运行的最小单位。
每个线程都有自己的上下文和独立的栈空间，它们可以并发地执行，并共享系统资源。
2. 调度器：ThreadX的调度器负责在不同的线程之间进行切换，以实现并发执行。
调度器使用轻量级的上下文切换机制，使得切换开销非常小。
3. 事件：ThreadX使用事件作为线程之间进行通信和同步的手段。
事件可以是信号量、消息队列、邮箱等，线程可以等待事件的发生，或者向事件发送信号。
4. 时钟和定时器：ThreadX具有高精度的时钟和定时器功能，可以实现以微秒级的精度进行时间管理。
这对于实时系统非常重要，可以保证任务在特定时间内得到执行。
5. 中断处理：ThreadX可以处理硬件中断，提供了中断服务例程（ISR）的支持，以响应硬件设备的事件。
6. 内存管理：ThreadX提供了灵活的内存管理机制，可以在运行时分配和释放内存，同时保证最小的内存碎片。
7. 低功耗支持：ThreadX支持低功耗模式，可以帮助嵌入式系统实现更长的电池寿命。
二、ThreadX的应用ThreadX在嵌入式系统的开发中有着广泛的应用。
下面将介绍ThreadX在不同领域的应用案例。
1. 汽车电子：在汽车电子领域，ThreadX被广泛用于车载控制系统、信息娱乐系统和车队通信系统等。
它可以实时响应车辆的控制指令和传感器数据，保证车辆系统的高可靠性和实时性。
2. 工业自动化：在工业自动化领域，ThreadX用于控制系统、机器人和自动化设备。
它可以管理各种任务并进行实时调度，确保工业过程的高效运行。
threadX学习笔记(1)(2)
原链接：/uid-20767397-id-600146.html/uid-20767397-id-600145.htmlthreadx学习笔记（一） 2008-10-11 20:31:55分类：tx_ill.s文件用来处理初始化过程中的汇编语言，它是面向处理器和开发工具的。
V oid_tx_initialize_low_level{1、CPSCR|= FIQ_ MODE,SET SP_fiq;2、CPSCR|=IRQ_MODE,SET SP_irp;3、CPSCR|=SVC_MODE,SET SP_svc;4、设置中断向量表IRQ_TABLE;5、设置内部TIMER线程的堆栈起始地址，堆栈大小和优先级：：tx_timer_stack_start,_tx_timer_stack_size,_tx_timer_priorit;6、设置初始化后未使用内存地址的初始值_tx_initialize_unused_memory;}Tx_tcs.s负责在中断发生时对上次的运行现场进行保存，它保存中断上下文，为了不覆盖R14_irq离得中断返回地址，TCS的返回是通过跳到__tx_irq_processing_return地址做到的。
Tx_TCR.S负责中断处理程序执行完后的处理。
V oid _tx_thread_context_save{1、把表示中断嵌套个数的变量 _tx_thread_system_state++;2、if _tx_thread_system_state>1,PUSH R0-R3,CPSR,R14 in IRQ stack,B __tx_irq_processing_return;3、else if _tx_thread_current_ptr=0判断是否有线程正在运行，if not ,B _tx_irq_processing_return;4、else,PUSH Context_irq in thread’s stack,SP_thread=new SP,B _tx_irq_processing_return; }由于R13和R14在不同的CPU模式下对应的是不同的物理寄存器，所以若要得到中断前的线程堆栈指针，需要先返回到该线程的运行模式，同时禁止中断，取值后再返回到终端模式。
ThreadXUserGuide-中文手册
Picokernel 结构 不象其它传统微内核结构的压条法功能（layering kernel functions），ThreadX 服务直 接进入其核心，使得转换和命令的执行尽可能最快，这样的非压条法设计被称为 Picokernel 结构。
一个可能的标准 由于 ThreadX 的通用性，高性能的 picokernel 结构及强大的可移植性，ThreadX 有可能 成为嵌入式程序的工业标准。
嵌入式应用程序
嵌入式应用程序是指在类似于手机、通讯设备、汽车引擎、激光打印机、医疗设备等 产品的微处理器中执行的程序。嵌入式应用程序的另一个显著特点是其软件和硬件有其特定 的用途。
代替。
2
开始部分
本章讨论了 ThreadX 内核的安装、设置及使用。下面列出了本章所涉及到的主题： ■ 主机配置 ■ 安装目标的要求 ■ 附带说明书 ■ ThreadX 的安装 ■ ThreadX 的使用 ■ 例程 ■ 问题处理 ■ 结构选择 ■ ThreadX 的版本 ID
主机配置
嵌入式系统通常安装于 IBM-PC 机或 UNIX 主机上。在应用程序通过编译、联接后下载
ThreadX 的数据类型
在 ThreadX 中除通常控制体系的数据类型外，还包括一系列特殊的称为接口的数据类
型。这些特殊的数据类型可以直接映射成 C 编译器的数据类型，以此来确保在不同 C 编译
器间的通用性。详细的操作可以在附带磁盘的 tx_port.h 文件中找到。
delphi createanonymousthreadx 参数
delphicreateanonymousthreadx参数Delphi中创建匿名线程X的参数标题：Delphi中创建匿名线程X的参数在Delphi中，创建匿名线程X是一种常见的操作，它允许我们以更简洁的方式创建和管理线程。
然而，对于初学者来说，可能对如何正确地使用匿名线程X感到困惑。
在这篇文章中，我们将讨论Delphi 中创建匿名线程X的参数，帮助您更好地理解和使用它。
一、创建匿名线程X的基本步骤在Delphi中，创建匿名线程X的基本步骤如下：1.声明一个匿名类型，该类型应包含一个返回类型为TThread的函数。
2.使用CreateAnonymousThread函数创建一个新的线程实例。
二、创建匿名线程X的参数在Delphi中，创建匿名线程X需要指定一些参数，包括：1.线程函数：指定要执行的代码。
这个函数应该返回void，并且不接受任何参数。
2.线程参数：如果需要传递给线程函数的参数，可以使用这个参数。
它可以是任何类型的数据，例如整数、字符串或对象。
3.优先级：控制线程的执行顺序。
较低的优先级将使线程在等待队列中等待更高优先级的线程完成后开始执行。
4.选项：指定线程的行为。
例如，是否允许挂起、是否可以暂停和恢复等。
下面是一个简单的示例代码，展示了如何使用Delphi中的CreateAnonymousThread函数来创建一个匿名线程X：```delphitypeTMyThreadFunction=function:void;varThread:TThread;begin//定义一个匿名函数作为线程函数Thread:=TThread.CreateAnonymousThread(procedurebegin//在这里编写要执行的代码//...end);//设置线程的优先级和选项Thread.Priority:=tpNormal;Thread.FreeOnTerminate:=True;//启动线程Thread.Start;end;```在这个示例中，我们定义了一个匿名函数作为线程函数，并使用CreateAnonymousThread函数创建了一个新的线程实例。
threadx学习笔记
threadx学习笔记（一）tx_ill.s文件用来处理初始化过程中的汇编语言，它是面向处理器和开发工具的。
Void_tx_initialize_low_level{1、CPSCR|= FIQ_ MODE,SET SP_fiq;2、CPSCR|=IRQ_MODE,SET SP_irp;3、CPSCR|=SVC_MODE,SET SP_svc;4、设置中断向量表IRQ_TABLE;5、设置内部TIMER线程的堆栈起始地址，堆栈大小和优先级：：tx_timer_stack_start,_tx_timer_stack_size,_tx_timer_priorit;6、设置初始化后未使用内存地址的初始值_tx_initialize_unused_memory;}Tx_tcs.s负责在中断发生时对上次的运行现场进行保存，它保存中断上下文，为了不覆盖R14_irq离得中断返回地址，TCS的返回是通过跳到__tx_irq_processing_return地址做到的。
Tx_TCR.S 负责中断处理程序执行完后的处理。
Void _tx_thread_context_save{1、把表示中断嵌套个数的变量_tx_thread_system_state++;2、if _tx_thread_system_state>1,PUSH R0-R3,CPSR,R14 in IRQ stack,B __tx_irq_processing_return;3、else if _tx_thread_current_ptr=0判断是否有线程正在运行，if not ,B _tx_irq_processing_return;4、else,PUSH Context_irq in thr ead’s stack,SP_thread=new SP,B _tx_irq_processing_return;}由于R13和R14在不同的CPU模式下对应的是不同的物理寄存器，所以若要得到中断前的线程堆栈指针，需要先返回到该线程的运行模式，同时禁止中断，取值后再返回到终端模式。
threadx操作系统
ThreadX操作系统
简介
ThreadX是一款实时嵌入式操作系统，专为低功耗和资源受限的系统设计。
它提供了轻量级的线程管理、调度和通信机制，适用于从小型MCU到大型系统的各种应用。
特点
简洁高效
ThreadX的内核非常简洁，仅占用很小的代码空间，同时具备高效的性能。
其内核由纯汇编编写，采用精简的设计并充分利用硬件资源，因此能够在资源受限的设备上运行。
实时性能
ThreadX是一个实时操作系统，具备可预测的响应时间和低延迟。
它采用优先级调度算法，通过动态优先级机制确保高优先级任务的及时响应。
多线程支持
ThreadX支持同时运行多个线程，每个线程拥有自己的堆栈和上下文，且彼此之间独立运行。
线程可以通过消息队列、信号量、事件等方式进行通信和同步。
资源管理
ThreadX提供了丰富的资源管理机制，包括内存池、定时器、锁等。
这些机制使得软件开发人员能够更加方便地管理和分配系统资源，以提升系统的可用性和性能。
线程创建与管理
创建线程
在ThreadX中，可以通过tx_thread_create函数创建新线程。
以下是一个创建线程的示例代码：
```c TX_THREAD thread_1; UCHAR stack_1[1024];
void thread_1_entry(ULONG input) { // 线程逻辑 }
int main() { tx_kernel_enter(); tx_thread_create(&thread_1,。
thread常用方法
thread类是多线程编程中的一个重要概念。
一个thread对象就表示一个线程的活动。
要做多线程编程,创建thread对象是首要步骤。
thread类中常用的方法有:
1. start(): 启动一个线程,并执行run()方法。
这是最重要的一个方法,用于开始一个线程活动。
2. run(): 定义线程要完成的任务。
通常需要override此方法来指定线程任务内容。
3. join(): 等待线程终止。
可以对一个线程对象调用另一个线程的join()方法,此线程就会等待join线程结束后才继续执行。
4. interrupt(): 中断线程。
调用该方法会设置线程的中断标志。
可以用来中断正在执行的线程。
5. sleep(): 让当前线程暂停指定毫秒时间。
这可以用于需要等待或周期执行某任务的情况。
6. getName()/setName():获得/设置线程名称。
使用thread创建多线程代码范例如下:
1) 继承Thread类,重写run()方法;
2) 创建Thread实例,调用start()方法开始执行。
这样就可以启动一个新的线程,任务定义在run()中。
想要多个线程就重复创建更多Thread实例。
通过join等方法可以实现线程间协作。
综上所述,thread类封装了线程活动的基本过程,关键是理解start(),run(),join()等方法的用法,这样可以灵活控制多线程的执行顺序与协作方式。
在编写高效并发程序时,合理利用线程是最重要的技能。
THREADX操作系统各模块详解第一部分
THREADX深入学习简介最近在做THREADX移植项目，所以在开始学习THREADX操作系统。
想把自己学到的东西总结一下。
学习操作系统时，按照领导的意思把操作系统进行模块划分。
通过查找资料将操作系统划分为任务调度模块、任务管理模块、任务间同步和通信模块、内存管理模块、中断管理模块、时钟管理模块。
下面将分别对各个模块进行分析和研究。
我将深入介绍各个模块的工作原理，通过此文档能对操作系统的工作原理有深入的了解。
首先得我的分析是针对MIPS、ARM、251内核进行分析。
我移植的平台是16位的251平台。
个人认为移植一个操作系统，首先对操作系统的内核调度原理必须十分清楚，然后对你的移植平台架构、指令集也要十分清楚，比如说下面几个方面：1、子程序调用时PC值是怎么被保存得（MPIS，将子程序的返回值存放在了RA寄存器中，251是PC自动入栈（ECALL指令）退出时使用ERET等指令，ARM是在LR寄存器中要计算相应减去的数值）。
2、中断发生时（251PC自动入栈但顺序和子程序调用压入顺序不一样，中断返回使用RETI指令。
MIPS，PC是被存入了EPC寄存器中，使用eret指令。
ARM，LR中数值的计算，赋值给PC即可）2.任务调度操作系统的核心模块就是内核调度。
首先要弄清楚其调度原理。
带着下面几个问题去思考。
1、任务入口函数第一次是怎么被执行的。
2、任务是怎么被切换的。
3、任务是怎么被抢占的。
以上几个问题是任务调度的核心。
带着这几个问题去看内核源码发现任务调度使用的方法就是任务栈和系统栈，内核利用入栈和出栈完成对任务的调度和切换。
而任务被调度起来是依靠timer驱动来工作。
基于此分析可以得出内核调度重点是以下几个方面：1、明白任务栈的构建方式，即任务创建时初始化任务堆栈时保存的数据。
这些数据要根据具体的硬件平台去实现，这个栈的初始化就是解决上面的第一个问题的。
因为在内核调度时，任务第一次被执行是出此栈来执行对应的入口函数的。
threads注册方法 -回复
threads注册方法-回复threads是一个开源的多线程库，它提供了一种方便的方法用于在Python 中创建和管理多线程的功能。
本文将介绍threads的注册方法。
在开始之前，请确保已经安装了threads库。
如果尚未安装，可以使用pip命令来安装：pip install threads一、导入threads库首先，我们需要在Python脚本的开头导入threads库，这样我们才能使用其中的函数和类。
在脚本的开头添加以下代码：pythonimport threads二、创建线程函数接下来，我们需要定义一个函数作为线程的执行体。
这个函数将在启动线程时被调用，并且在线程执行期间被执行。
下面是一个简单的示例：pythondef thread_function():# 线程的执行逻辑三、注册线程在创建线程之前，我们需要先注册线程。
注册线程意味着我们告诉threads 库我们要创建一个新的线程，并提供它的执行体函数。
下面是一个示例：pythonthreads.register_thread(thread_function)这个函数接受一个参数，即线程执行体函数的名称。
通过调用这个函数，我们将线程注册到threads库中。
四、启动线程一旦线程被注册，我们可以通过调用threads库中的start_threads()函数来启动它们。
这个函数将会遍历所有已注册的线程并启动它们。
下面是一个示例：pythonthreads.start_threads()启动线程后，它们将开始并行执行。
五、等待线程完成如果我们希望等待所有线程完成后再继续执行主线程，我们可以使用threads库中的wait_threads()函数。
这个函数将会阻塞主线程，直到所有线程都完成。
下面是一个示例：pythonthreads.wait_threads()六、解除注册线程如果我们想要取消某个线程的注册，以防止其被启动和执行，我们可以使用threads库中的unregister_thread()函数。
java中Thread源码介绍
java中Thread源码介绍概述 Thread是线程的意思，在Java中我们⼀般都说多线程，⽽没有提过多进程，⽽且⼤家都知道，java中的多线程是真正的多线程，可以使⽤多核并⾏处理，⽽像python的多线程就是伪多线程，只能说是并发处理，那⼤家有没有好奇，jvm虚拟机相对于操作系统来说是⼀个进程，如果⼀个进程只能占⽤⼀个cpu，那jvm中多线程⼜如何实现在多核处理呢？还有操作系统对于进程状态有三个基本的定义，就绪状态、运⾏状态、阻塞状态，这三个状态和我们在java中说线程处于阻塞状态、就绪状态是不是⼀样的？本⽂就聊聊java中的线程，之后会分析⼀下Java的Thread类的源码。
线程操作系统中引⼊进程是为了使多个程序并发执⾏，改善资源利⽤率，进程是操作系统中进⾏除处理器外的资源分配和保护的基本单位。
线程是进程中能够并发执⾏的实体，共享进程的主存空间和资源，是处理器调度和分配的基本单位。
操作系统线程模型要想搞明⽩java如何实现的多线程，要先搞明⽩线程的分类，线程分类如下：⽤户线程：⽤户线程是在⽤户空间实现，线程创建、调度、同步都是都是⽤户⾃⼰代码实现的，操作系统只知道⽤户线程的进程，⽽该进程下的线程对内核⽽⾔是不可见的，任意给定时刻都只能有⼀个线程在执⾏，如果进程某⼀个线程发⽣阻塞，整个进程都会阻塞。
内核线程：由内核创建管理，⼀个内核线程阻塞不会影响别的内核线程，因为其是调度的基本单位，有点类似于进程，不过⽐进程开销⼩。
从上⾯分析可知，内核线程是由内核创建管理，看上去好像和我们⾃⼰写的程序运⾏没什么关系，其实不然，因为操作系统的内存管理，进程调度等都需要内核线程来完成，所以我们⾃⼰写的程序的线程要和内核中的线程对应起来。
我们⾃⼰写的程序运⾏在⽤户空间，那对应的线程就是⽤户线程，按照上⾯的介绍，⼀个进程下的⽤户线程⼀次只能有⼀个运⾏，那这就不是并⾏了，这种情况的原因就是多个⽤户线程对应⼀个内核线程，然后在CPU资源分配上，只给该⽤户线程对应的进程分配了⼀个核执⾏，⽽如果要想实现真正的并⾏，需要使⽤⼀对⼀或者多对多线程模型，⼀对⼀就是说，⼀个⽤户线程对应⼀个内核线程，然后就可以分配到不同的CPU上运⾏。
Java源码分析九（Thread）
Java源码分析九（Thread）Java源码分析九（Thread）本⽂在⽂字解读⽅⾯借鉴了很多博客多线程编程⼀直是业界公认⽐较难也是⽐较重要，⽽且是⾮常基础的⼀点，掌握它⾮常重要。
Java中多线程编程⽐较幸福，因为Jdk⼯程师们考虑了很多东西尽量减少使⽤Java的难度和复杂度。
其实在C++之中是没有内建多线程的，它依赖操作系统提供这个特性，因为C++为了效率，控制C++适⽤的应⽤程序的范围。
即C++没有内建多线程，它允许你直接使⽤操作系统提供的多线程。
这也意味着你在Linux系统下编写的C++多线程代码很有可能在Windows下不能运⾏，这也是架构师技术选型的时候⼀个重要考虑点。
什么线程线程就是操作系统的最⼩运⾏单位，在线程之上还有进程。
Java允许有多线程。
Java之中线程有优先级priority，⼦线程优先级默认和⽗线程⼀样。
Java中线程的周期**多线程的声明周期概念：Java之中线程的实现在Java之中线程控制和业务分离，⽽且线程的实现有两种⽅式：守护线程和⾮守护线程守护（daemon）线程：服务其他的线程，⽐如垃圾回收线程,就是最典型的守护线程。
它的最主要特征是：**它守护的线程挂了，它就会停⽌执⾏，即使它的实现⾥⾯有finally块。
即daemon线程的finally块不⼀定执⾏** ⾮守护（daemon）线程：⽤户线程，它的特征是：除⾮主动终⽌，否则任务会⼀直执⾏，直到terminated触发。
User Thread线程和Daemon Thread守护线程本质上来说去没啥区别的，唯⼀的区别之处就在虚拟机的离开：如果User Thread全部撤离，那么Daemon Thread也就没啥线程好服务的了，所以虚拟机也就退出了。
**即user thread会在⾃⼰的任务执⾏完之后才会退出，即使⽗线程退出了。
** **thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出⼀个IllegalThreadStateException异常**Thread的⼀些基本属性1. name 线程的名称。
thread 写法
thread 写法一、基本概念Thread 是编程中的一个重要概念，指的是程序中的执行线程。
在多线程编程中，多个任务可以同时执行，从而提高程序的运行效率。
在 Java、C#、Python 等编程语言中，都有对线程的支持。
二、Thread 的创建创建 Thread 的方式因编程语言而异。
以 Java 和 C# 为例，介绍两种常见的创建方式。
1. Java 中创建 Thread 的方式：* 继承 Thread 类：需要重写 run() 方法，在该方法中编写线程要执行的代码。
* 实现 Runnable 接口：将实现该接口的对象作为参数传递给 Thread 对象，然后调用 Thread 对象的 start() 方法启动线程。
2. C# 中创建 Thread 的方式：* 使用 Thread 类：需要创建 Thread 对象，并调用其 Start() 方法启动线程。
在 Start() 方法内部，需要调用委托（Delegate）来指定线程要执行的代码。
无论是哪种方式，都需要在创建线程后调用 start() 方法启动线程，并在需要的时候调用 Thread 对象或委托的 Join() 方法等待线程执行完毕。
三、线程的同步和互斥在多线程编程中，为了保证数据的一致性和正确性，通常需要进行线程同步和互斥。
常见的同步机制包括锁（Lock）和信号量（Semaphore）等。
在使用这些机制时，需要注意避免死锁和竞态条件等问题。
四、线程的优先级和调度大多数编程语言都支持线程的优先级和调度。
通过设置线程的优先级，可以控制线程的执行顺序。
不同的编程语言有不同的调度机制，需要根据具体语言文档进行了解和设置。
五、常见问题及解决方案在多线程编程中，常见的问题包括竞态条件、死锁、线程泄露等。
针对这些问题，需要采取相应的解决方案，如使用锁的粒度控制、合理分配资源、避免长时间占用资源等。
六、线程的应用场景线程在多任务环境下具有很高的应用价值，可以大大提高程序的运行效率。
学习线程池源码--ThreadPoolExecutor
学习线程池源码--ThreadPoolExecutor1 创建ThreadPoolExecutorThreadPollExecutor有四个构造函数，但本质上都是调⽤这⼀个构造函数。
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {...}corePoolSize: 线程池核⼼线程数量maximumPoolSize：线程池最⼤线程数量keepAliveTime：线程空闲时间unit：空闲时间单位workQueue：⼯作队列，没有空闲线程时新加的任务会放⼊⼯作队列中排队等待。
⼯作队列共有四种实现：a.ArrayBlockingQueue: 创建固定⼤⼩的阻塞队列，采⽤的是数组的结构⽅式b.LinkedBlockingQueue: 创建固定⼤⼩的阻塞队列，如果为传⼊参数，则会创建Integer.MaxValue⼤⼩的队列c.SynchronousQueue: 创建⼀个不存储元素的阻塞队列，每⼀个元素的插⼊都必须等待⼀个元素的移除操作，不然会⼀直阻塞。
d.PriorityBlockingQueue: ⼀个具有优先级的⽆限阻塞队列。
threadFactory：线程⼯⼚，⽤于创建线程池中的线程，可以⾃⼰实现，默认⼯⼚创建的线程名称为-poolNumber-thread-threadNumber，如：pool-1-thread-10handler: 拒绝策略，当线程池线程达到最⼤后添加任务不能被执⾏时的处理策略。
拒绝策略有4种实现，当然也可以⾃⼰实现（继承RejectExecutionHandle）。
threadx多任务例程
threadx多任务例程下面是一个简单的ThreadX多任务例程的示例：```c#include "tx_api.h"/* 定义任务堆栈空间 */#define TASK_STACK_SIZE 1024/* 定义任务控制块 */TX_THREAD task1_thread;TX_THREAD task2_thread;/* 定义任务入口函数 */void task1_entry(ULONG thread_input){while(1){/* 执行任务1的操作 */tx_thread_sleep(1000); /* 暂停1秒钟 */ }}void task2_entry(ULONG thread_input){while(1){/* 执行任务2的操作 */tx_thread_sleep(2000); /* 暂停2秒钟 */ }}int main(void){/* 初始化ThreadX内核 */tx_kernel_enter();/* 在初始化线程之前创建任务1 */tx_thread_create(&task1_thread, "Task 1", task1_entry, 0, TASK_STACK_SIZE, 1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);/* 在初始化线程之前创建任务2 */tx_thread_create(&task2_thread, "Task 2", task2_entry, 0, TASK_STACK_SIZE, 2, 2, TX_NO_TIME_SLICE, TX_AUTO_START);/* 启动ThreadX内核调度 */tx_kernel_start();return 0;}```在上面的例程中，使用了两个任务 `task1_thread` 和`task2_thread`，通过调用 `tx_thread_create` 函数创建。
threadx学习笔记
threadx学习笔记（一）tx_ill.s文件用来处理初始化过程中的汇编语言，它是面向处理器和开发工具的。
Void_tx_initialize_low_level{1、CPSCR|= FIQ_ MODE,SET SP_fiq;2、CPSCR|=IRQ_MODE,SET SP_irp;3、CPSCR|=SVC_MODE,SET SP_svc;4、设置中断向量表IRQ_TABLE;5、设置内部TIMER线程的堆栈起始地址，堆栈大小和优先级：：tx_timer_stack_start,_tx_timer_stack_size,_tx_timer_priorit;6、设置初始化后未使用内存地址的初始值_tx_initialize_unused_memory;}Tx_tcs.s负责在中断发生时对上次的运行现场进行保存，它保存中断上下文，为了不覆盖R14_irq离得中断返回地址，TCS的返回是通过跳到__tx_irq_processing_return地址做到的。
Tx_TCR.S负责中断处理程序执行完后的处理。
Void _tx_thread_context_save{1、把表示中断嵌套个数的变量 _tx_thread_system_state++;2、if _tx_thread_system_state>1,PUSH R0-R3,CPSR,R14 in IRQ stack,B__tx_irq_processing_return;3、else if _tx_thread_current_ptr=0判断是否有线程正在运行，if not ,B_tx_irq_processing_return;4、else,PUSH Context_irq in thread’s stack,SP_thread=new SP,B_tx_irq_processing_return;}由于R13和R14在不同的CPU模式下对应的是不同的物理寄存器，所以若要得到中断前的线程堆栈指针，需要先返回到该线程的运行模式，同时禁止中断，取值后再返回到终端模式。
Thread类源码解析
Thread类源码解析源码版本:jdk8其中的部分论证和⽰例代码:类声明:Thread本⾝实现了Runnable接⼝Runnable:任务,《java编程思想》中表⽰该命名不好，或许叫Task更好；Thread：线程，执⾏任务的载体；public class Thread implements Runnable**构造⽅法: **构造时,可以指定线程组,线程运⾏任务Runnable对象,线程名和栈⼤⼩线程的所有构造⽅法,都是通过init()实现/*** Thread的所有public构造⽅法传⼊的inheritThreadLocals均为true* 只有⼀个权限为default的构造⽅法传⼊为false* 所有的构造⽅法实现均是调⽤了该⽅法*/private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {// 构造⽅法中传⼊的线程名不能为null// 默认线程名:"Thread-" + nextThreadNum()if (name == null) {throw new NullPointerException("name cannot be null");} = name;// 被创建出来的线程是创建线程的⼦线程Thread parent = currentThread();// 新建线程的线程组// 如果构造⽅法传⼊的线程组为null,则通过这个流程来决定其线程组,通常,新建线程的线程组为其创建线程的线程组 SecurityManager security = System.getSecurityManager();if (g == null) {/* Determine if it's an applet or not *//* If there is a security manager, ask the security managerwhat to do. */if (security != null) {g = security.getThreadGroup();}/* If the security doesn't have a strong opinion of the matteruse the parent thread group. */if (g == null) {g = parent.getThreadGroup();}}/* checkAccess regardless of whether or not threadgroup isexplicitly passed in. */g.checkAccess();/** Do we have the required permissions?*/if (security != null) {if (isCCLOverridden(getClass())) {security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);}}g.addUnstarted();this.group = g;// ⼦线程默认拥有⽗线程的优先级和daemon属性this.daemon = parent.isDaemon();this.priority = parent.getPriority();if (security == null || isCCLOverridden(parent.getClass()))this.contextClassLoader = parent.getContextClassLoader();elsethis.contextClassLoader = parent.contextClassLoader;this.inheritedAccessControlContext =acc != null ? acc : AccessController.getContext();this.target = target;setPriority(priority);if (inheritThreadLocals && parent.inheritableThreadLocals != null)this.inheritableThreadLocals =ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);/* Stash the specified stack size in case the VM cares */this.stackSize = stackSize;// 产⽣新的tid并设置tid = nextThreadID();}public long getId() {return tid;}上⾯的源码中有⼀个stackSize的参数,这个⼀般不会使⽤,其具体请参考javadoc.默认线程名:"Thread-" + nextThreadNum():/* For autonumbering anonymous threads. */private static int threadInitNumber;// 同步⽅法,保证tid的唯⼀性和连续性private static synchronized int nextThreadNum() {return threadInitNumber++;}// 线程名可以被修改public final synchronized void setName(String name) {checkAccess();if (name == null) {throw new NullPointerException("name cannot be null");} = name;if (threadStatus != 0) {setNativeName(name);}}public final String getName() {return name;}ThreadGroup:《java编程思想》有云：把ThreadGroup当做是⼀次不成功的尝试即可，不⽤理会⽰例:public final ThreadGroup getThreadGroup() {return group;}Thread类默认的toString()中有使⽤其ThreadGroup:public String toString() {ThreadGroup group = getThreadGroup();if (group != null) {return "Thread[" + getName() + "," + getPriority() + "," + group.getName() + "]";} else {return "Thread[" + getName() + "," + getPriority() + "," + "" + "]";}}守护线程:具体参考:⽰例:/*** Marks this thread as either a {@linkplain #isDaemon daemon} thread* or a user thread. The Java Virtual Machine exits when the only* threads running are all daemon threads.* <p> This method must be invoked before the thread is started.*/public final void setDaemon(boolean on) {checkAccess();// 只有在线程开始前设置才有效if (isAlive()) {throw new IllegalThreadStateException();}daemon = on;}public final boolean isDaemon() {return daemon;}// 返回当前线程是否还活着// start()后且还没有死亡的线程均视为活着的线程public final native boolean isAlive();线程优先级和线程状态：⽰例:构造时如果不指定,默认线程优先级就是NORM_PRIORITYpublic final static int MIN_PRIORITY = 1;public final static int NORM_PRIORITY = 5;public final static int MAX_PRIORITY = 10;public final void setPriority(int newPriority) {ThreadGroup g;checkAccess();// 优先级范围 1~10if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {throw new IllegalArgumentException();}if((g = getThreadGroup()) != null) {if (newPriority > g.getMaxPriority()) {newPriority = g.getMaxPriority();}// 设置优先级setPriority0(priority = newPriority);}}public final int getPriority() {return priority;}private native void setPriority0(int newPriority);/*** A thread state. A thread can be in one of the following states:* NEW:A thread that has not yet started is in this state.* RUNNABLE:A thread executing in the Java virtual machine is in this state.* BLOCKED:A thread that is blocked waiting for a monitor lock is in this state.* WAITING:A thread that is waiting indefinitely for another thread to* perform a particular action is in this state.* TIMED_WAITING:A thread that is waiting for another thread to perform an action* for up to a specified waiting time is in this state.* TERMINATED:A thread that has exited is in this state.* A thread can be in only one state at a given point in time.* These states are virtual machine states which do not reflect* any operating system thread states.* @since 1.5*/public enum State {// 创建后,但是没有start(),调⽤了start()后,线程才算准备就绪,可以运⾏(RUNNABLE)NEW,// 正在运⾏或正在等待操作系统调度RUNNABLE,// 线程正在等待监视器锁// 正在synchronized块/⽅法上等待获取锁,或者调⽤了Object.wait(),等待重新获得锁进⼊同步块BLOCKED,// 调⽤Object.wait(),Thread.join()或LockSupport.park()会进⼊该状态,注意这⾥的调⽤均为没有设置超时,// 线程正在等待其他线程进⾏特定操作,⽐如,调⽤了Object.wait()的线程在另⼀个线程调⽤Object.notify()/Object.notifyAll()// 调⽤了Thread.join()的线程在等待指定线程停⽌,join()的内部实现⽅式也是Object.wait(),只不过其Object就是线程对象本⾝WAITING,// 调⽤Thread.sleep(),Object.wait(long),Thread.join(long),// LockSupport.parkNanos(long),LockSupport.parkUntil(long)会进⼊该状态,// 注意,这⾥的调⽤均设置了超时TIMED_WAITING,// 线程执⾏完成,退出TERMINATED;}// @since 1.5public State getState() {// get current thread statereturn sun.misc.VM.toThreadState(threadStatus);}这⾥关于线程状态需要特别注意,在⽹上有很多博客和书籍对线程状态进⾏讲解,其中很⼤⼀部分是错误的,对于BLOCKED,WAITING和TIMED_WAITING有所误解,认为⼀个线程在被从Object.wait()中被唤醒时,会⽴即进⼊Runnable状态,其实不是的:⼀个线程在被从Object.wait()中被唤醒时,会⽴即进⼊BLOCKED状态,这时其并没有获得锁,只是被唤醒了,再次开始对Object的监视器锁进⾏竞争;只有在其竞争获得锁之后才会进⼊RUNNABLE状态.在理解java线程状态时,建议直接看Thread.State的注释,就看英⽂版本,最贴切,没有杂质,也最正确,其他的所有书上的讲解似乎都有些偏颇线程状态⽰例:线程优先级⽰例:关于wait()/notify()具体相关,请参考其他相关博客;run():如果是构造Thread对象的时候,传⼊了该对象预期执⾏的任务----Runnable对象时,执⾏该任务,否则,什么都不做,当然,可以通过集成Thread类,重写run(),来修改其⾏为:/* What will be run. */private Runnable target;@Overridepublic void run() {if (target != null) {target.run();}}线程启动:调⽤start()与调⽤run()的区别:懒得说/* Java thread status for tools,* initialized to indicate thread 'not yet started'*/private volatile int threadStatus = 0;// 启动线程,JVM会调⽤当前Thread对象的run()// 同步⽅法public synchronized void start() {// A zero status value corresponds to state "NEW".// 如果调⽤时不是在线程状态不是NEW,则抛出IllegalThreadStateExceptionif (threadStatus != 0)throw new IllegalThreadStateException();/* Notify the group that this thread is about to be started* so that it can be added to the group's list of threads* and the group's unstarted count can be decremented. */group.add(this);boolean started = false;try {// 通过start0()来实现线程启动start0();started = true;} finally {try {if (!started) {group.threadStartFailed(this);}} catch (Throwable ignore) {/* do nothing. If start0 threw a Throwable thenit will be passed up the call stack */}}}private native void start0();线程打断:⽰例:/* The object in which this thread is blocked in an interruptible I/O* operation, if any. The blocker's interrupt method should be invoked* after setting this thread's interrupt status.*/private volatile Interruptible blocker;private final Object blockerLock = new Object();/* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code*/void blockedOn(Interruptible b) {synchronized (blockerLock) {blocker = b;}}/*** 打断当前执⾏线程* 如果当前线程阻塞在Object.wait(),Thread.join(),Thread.sleep()上,* 那么该线程会收到InterruptedException,且线程的打断标志会被清除;* 如果当前线程阻塞在InterruptibleChannel上,那么该InterruptibleChannel* 会被关闭,线程的打断标志会被置位,且当前线程会收到ClosedByInterruptException;* 如果当前线程阻塞在Selector上,那么该Selector的selection操作将会⽴即返回⼀个⾮0的结果, * 且Selector.wakeup()会被调⽤,线程的打断标志会被置位,* 如果上述情况均不存在,将当前线程的打断标志置位* 打断⼀个isAlive()返回false的线程没有效果,isInterrupted()仍然会返回false;*/public void interrupt() {if (this != Thread.currentThread())checkAccess();synchronized (blockerLock) {Interruptible b = blocker;// 在Interruptible上阻塞if (b != null) {interrupt0(); // Just to set the interrupt flagb.interrupt(this);return;}}interrupt0();}private native void interrupt0();/*** 返回线程是否被打断(打断标志是否被置位)* 传⼊的参数决定是否该⽅法是否会清除终端标志位*/private native boolean isInterrupted(boolean ClearInterrupted);public static boolean interrupted() {return currentThread().isInterrupted(true);}public boolean isInterrupted() {return isInterrupted(false);}关于isInterrupted()和interrupted()的区别,上述源码表现得很明显⽽且,也体现了NIO的可中断中断实现⽅式注意:interrupt()不能中断执⾏阻塞IO操作的线程.线程的礼让—— yield() sleep() join():关于Thread.sleep()和Object.wait()的区别:参考⽰例:/*** 暗⽰调度器让出当前线程的执⾏时间⽚,调度器可以选择忽略该暗⽰;* 该⽅法在⽤来调试和测试时可能很有⽤,可以⽤来重现需要特殊条件才能复现的bug;* 也可以⽤来进⾏并发优化等;*/public static native void yield();/*** 当前执⾏线程休眠指定毫秒在休眠期间,不释放任何当前线程持有的锁;*/public static native void sleep(long millis) throws InterruptedException;/*** 当前执⾏线程休眠指定毫秒在休眠期间,不释放任何当前线程持有的锁;* 如果当前被打断(该⽅法调⽤前或该⽅法调⽤时),抛出InterruptedException,同时将打断标志清掉 */public static void sleep(long millis, int nanos) throws InterruptedException {// 取值范围检查if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (nanos < 0 || nanos > 999999) {throw new IllegalArgumentException("nanosecond timeout value out of range");}// 纳秒最后还是转换成了毫秒233333// 可能是考虑都有些if (nanos >= 500000 || (nanos != 0 && millis == 0)) {millis++;}sleep(millis);}/*** 当前执⾏线程等待指定线程(也就是该调⽤发⽣的Thread对象)死后再继续执⾏;* 可以设置超时,如果设置超时为0,则为不设置超时;* 线程结束时(terminate),将会调⽤⾃⾝的notifyAll(),唤醒在该Thread对象上wait()的⽅法;* 如果该线程被打断,该⽅法将抛出InterruptedException,并将打断标志位清除 */// 同步⽅法,同步当前Thread对象,所以才能在其内部调⽤wait()public final synchronized void join(long millis)throws InterruptedException {long base = System.currentTimeMillis();long now = 0;if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}// 使⽤isAlive()和wait()的循环实现if (millis == 0) {while (isAlive()) {wait(0);}} else {while (isAlive()) {long delay = millis - now;if (delay <= 0) {break;}wait(delay);now = System.currentTimeMillis() - base;}}}public final synchronized void join(long millis, int nanos)throws InterruptedException {if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (nanos < 0 || nanos > 999999) {throw new IllegalArgumentException("nanosecond timeout value out of range");}if (nanos >= 500000 || (nanos != 0 && millis == 0)) {millis++;}join(millis);}public final void join() throws InterruptedException {join(0);}/*** This method is called by the system to give a Thread* a chance to clean up before it actually exits.*/private void exit() {if (group != null) {group.threadTerminated(this);group = null;}/* Aggressively null out all reference fields: see bug 4006245 */target = null;/* Speed the release of some of these resources */threadLocals = null;inheritableThreadLocals = null;inheritedAccessControlContext = null;blocker = null;uncaughtExceptionHandler = null;}被遗弃的⽅法——suspend() resume() stop():⽰例:关于这些⽅法被遗弃的原因,具体参考:/*** 挂起当前线程* 弃⽤原因:容易导致死锁*/@Deprecatedpublic final void suspend() {checkAccess();suspend0();}/*** 从suspend()中恢复线程运⾏* 弃⽤原因:容易导致死锁*/@Deprecatedpublic final void resume() {checkAccess();resume0();}/*** 强制线程停⽌执⾏;* 通过抛出⼀个ThreadDeath的⽅式来停⽌线程;* 废弃原因:stop()会师范所有已持有的锁的监视器,如果存在之前被这些监视器保护的对象处于⼀个不连续* 的状态(inconsistent state),这些被损坏的对象将会对其他线程可见,出现不可预期的⾏为;*/@Deprecatedpublic final void stop() {SecurityManager security = System.getSecurityManager();if (security != null) {checkAccess();if (this != Thread.currentThread()) {security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);}}// A zero status value corresponds to "NEW", it can't change to// not-NEW because we hold the lock.if (threadStatus != 0) {resume(); // Wake up thread if it was suspended; no-op otherwise}// The VM can handle all thread statesstop0(new ThreadDeath());}ThreadLocal:在Thread类中有两个与ThreadLocal相关的成员变量具体有关ThreadLocal,请参考:/* ThreadLocal values pertaining to this thread. This map is maintained* by the ThreadLocal class. */ThreadLocal.ThreadLocalMap threadLocals = null;/** InheritableThreadLocal values pertaining to this thread. This map is* maintained by the InheritableThreadLocal class.*/ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;ClassLoader:关于ClassLoader,我暂时知道的也不多,先知道这个,以后有机会专门研究⼀下ClassLoader: /* The context ClassLoader for this thread */private ClassLoader contextClassLoader;/*** 当前线程的ClassLoader,默认创建时是⽗线程的ClassLoader* @return the context ClassLoader for this Thread, or {@code null}* indicating the system class loader (or, failing that, the* bootstrap class loader)* @since 1.2*/@CallerSensitivepublic ClassLoader getContextClassLoader() {if (contextClassLoader == null)return null;SecurityManager sm = System.getSecurityManager();if (sm != null) {ClassLoader.checkClassLoaderPermission(contextClassLoader,Reflection.getCallerClass());}return contextClassLoader;}/*** @param cl* the context ClassLoader for this Thread, or null indicating the* system class loader (or, failing that, the bootstrap class loader)* @since 1.2*/public void setContextClassLoader(ClassLoader cl) {SecurityManager sm = System.getSecurityManager();if (sm != null) {sm.checkPermission(new RuntimePermission("setContextClassLoader"));}contextClassLoader = cl;}线程栈轨迹:// 特殊编程技巧private static final StackTraceElement[] EMPTY_STACK_TRACE= new StackTraceElement[0];private native static StackTraceElement[][] dumpThreads(Thread[] threads);private native static Thread[] getThreads();// 打印当前线程的栈轨迹(StackTrace),通过新建⼀个异常的⽅式实现// 注意:这是⼀个静态⽅法public static void dumpStack() {new Exception("Stack trace").printStackTrace();}/*** 获得栈轨迹,返回的是⼀个数组* 数组的第0个栈轨迹为最近调⽤的栈轨迹* @since 1.5*/public StackTraceElement[] getStackTrace() {if (this != Thread.currentThread()) {// check for getStackTrace permissionSecurityManager security = System.getSecurityManager();if (security != null) {security.checkPermission(SecurityConstants.GET_STACK_TRACE_PERMISSION);}// 不是活着的,返回的栈轨迹长度为0if (!isAlive()) {return EMPTY_STACK_TRACE;}StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[] {this});StackTraceElement[] stackTrace = stackTraceArray[0];// a thread that was alive during the previous isAlive call may have// since terminated, therefore not having a stacktrace.if (stackTrace == null) {// 这样就不会返回null,调⽤者也⽆需判断null了stackTrace = EMPTY_STACK_TRACE;}return stackTrace;} else {// Don't need JVM help for current threadreturn (new Exception()).getStackTrace();}}/*** 返回所有线程的栈轨迹* @since 1.5*/public static Map<Thread, StackTraceElement[]> getAllStackTraces() {// check for getStackTrace permissionSecurityManager security = System.getSecurityManager();if (security != null) {security.checkPermission(SecurityConstants.GET_STACK_TRACE_PERMISSION);security.checkPermission(SecurityConstants.MODIFY_THREADGROUP_PERMISSION);}// Get a snapshot of the list of all threadsThread[] threads = getThreads();StackTraceElement[][] traces = dumpThreads(threads);Map<Thread, StackTraceElement[]> m = new HashMap<>(threads.length);for (int i = 0; i < threads.length; i++) {StackTraceElement[] stackTrace = traces[i];if (stackTrace != null) {m.put(threads[i], stackTrace);}// else terminated so we don't put it in the map}return m;}UncaughtExceptionHandler:⽰例:// null unless explicitly setprivate volatile UncaughtExceptionHandler uncaughtExceptionHandler;// null unless explicitly setprivate static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;/*** 设置UncaughtExceptionHandler,该设置对所有线程有效* 如果⾃⾝没有设置,则交给其线程组的UncaughtExceptionHandler处理,如果再没有,* 则交给默认的的UncaughtExceptionHandler处理,也即这⾥设置的UncaughtExceptionHandler处理 * 注意这⾥的设置不应该设置为线程的线程组,这样的设置会造成死循环* @since 1.5*/public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {SecurityManager sm = System.getSecurityManager();if (sm != null) {sm.checkPermission(new RuntimePermission("setDefaultUncaughtExceptionHandler")); }defaultUncaughtExceptionHandler = eh;}/*** 返回默认的UncaughtExceptionHandler,该UncaughtExceptionHandler对所有线程有效* 这是⼀个静态⽅法* @since 1.5*/public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){return defaultUncaughtExceptionHandler;}/*** 返回该线程的UncaughtExceptionHandler,如果没有,返回该线程的线程组* ThreadGroup本⾝实现了UncaughtExceptionHandler接⼝* @since 1.5*/public UncaughtExceptionHandler getUncaughtExceptionHandler() {return uncaughtExceptionHandler != null ?uncaughtExceptionHandler : group;}/*** 设置该线程的UncaughtExceptionHandler*/public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {checkAccess();uncaughtExceptionHandler = eh;}/*** uncaught exception 分发给UncaughtExceptionHandler* 该⽅法被JVM调⽤*/private void dispatchUncaughtException(Throwable e) {getUncaughtExceptionHandler().uncaughtException(this, e);}其他:// 返回当前语句执⾏的线程public static native Thread currentThread();// 不能克隆线程@Overrideprotected Object clone() throws CloneNotSupportedException {throw new CloneNotSupportedException();}/*** 返回该线程是否持有指定对象的监视器锁* @since 1.4*/public static native boolean holdsLock(Object obj);。
java thread 写法
在Java中，创建一个线程可以通过实现Runnable接口或者继承Thread类来实现。
下面是两种常见的方法：
方法一：实现Runnable接口
java复制代码
public class MyRunnable implements Runnable {
public void run() {
// 线程执行的代码
}
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start();
}
}
在这个例子中，我们创建了一个实现了Runnable接口的类MyRunnable，然后我们创建了一个新的线程并把MyRunnable实例作为参数传递给线程构造器，最后调用start()方法启动线程。
方法二：继承Thread类
java复制代码
public class MyThread extends Thread {
public void run() {
// 线程执行的代码
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
在这个例子中，我们创建了一个继承了Thread类的类MyThread，然后我们创建了一个新的线程并调用
start()方法启动线程。
注意，run()方法是线程执行的代码，它是Thread类的一个受保护的方法，所以我们在子类中必须重写这个方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
threadx学习笔记（一）tx_ill.s文件用来处理初始化过程中的汇编语言，它是面向处理器和开发工具的。
Void_tx_initialize_low_level{1、CPSCR|= FIQ_ MODE,SET SP_fiq;2、CPSCR|=IRQ_MODE,SET SP_irp;3、CPSCR|=SVC_MODE,SET SP_svc;4、设置中断向量表IRQ_TABLE;5、设置内部TIMER线程的堆栈起始地址，堆栈大小和优先级：：tx_timer_stack_start,_tx_timer_stack_size,_tx_timer_priorit;6、设置初始化后未使用内存地址的初始值_tx_initialize_unused_memory;}Tx_tcs.s负责在中断发生时对上次的运行现场进行保存，它保存中断上下文，为了不覆盖R14_irq离得中断返回地址，TCS的返回是通过跳到__tx_irq_processing_return地址做到的。
Tx_TCR.S负责中断处理程序执行完后的处理。
Void _tx_thread_context_save{1、把表示中断嵌套个数的变量_tx_thread_system_state++;2、if _tx_thread_system_state>1,PUSH R0-R3,CPSR,R14 in IRQ stack,B __tx_irq_processing_return;3、else if _tx_thread_current_ptr=0判断是否有线程正在运行，if not ,B _tx_irq_processing_return;4、else,PUSH Context_irq in thread’s stack,SP_thread=new SP,B _tx_irq_processing_return;}由于R13和R14在不同的CPU模式下对应的是不同的物理寄存器，所以若要得到中断前的线程堆栈指针，需要先返回到该线程的运行模式，同时禁止中断，取值后再返回到终端模式。
R14_irq 保存的是终端发生时PC值+8，R14_svc保存得失中断前线程自己的返回地址。
所以在中段上下文中，（R14_irq-4）应该存在中断地址，而R14_svc存在R14的位置。
Void _tx_thread_context_restore{1、_tx_thread_system_state--,if_tx_thread_system_state>0,POP R0-R3,CPSR,R14 from IRQ stack,BX R14;2、else if _tx_thread_current_ptr=0?if =0CPSR|=VC_MODE,CPSR|=TX_INT_ENABLE,跳到线程调度程序B_tx_thread_schedule;3、if!=0,则判断线程抢占是否禁止if_tx_threa d_preempt_disable=0?if!=0,POP Context_irq from thread’s stack,BX R14;4、if=0,_tx_timer_time_slice=newvalue,_tx_thread_current_ptr=0,CPSR|=SVC_MODE,设置堆栈指针为系统指针SP=SP_svc，CPSR|=TX_INT_ENABLE;5、B _tx_thread_schedule;}Tx_tsr.s用于从线程退回到系统态，负责保存线程的最小语境并退回到Threadx的调度循环状态。
它保存的上下文是请求上下文。
Void _tx_thread_system_return{1、PUSH Context_request:in thread’sstack,CPSR|=TX_INT_DISABLE;2、_tx_thread_current_ptr->SP=SP,CPSR|=SVC_MODE;3、设置堆栈指针为系统指针SP=SP_svc，_tx_thread_current_ptr=0,CPSR|=TX_INT_ENABLE;4、 B _tx_thread_schedule;}由于用户模式不能直接更改CPSR来关断的，所以要通过SWI 指令进入特权模式，而且特权模式和用户模式的SP对应不同的物理寄存器，所以要在转入系统模式取得用户模式下SP，最后再回到特权模式。
TX_TS.S负责调度和恢复就绪的优先级最高的线程的最后语境。
Void _tx_thread_schedule{1、while(_tx_thread_execute_ptr=0);2、CPSR|=TX_INT_DISABLE,_tx_threadx_current_ptr=_tx_thread_execute_ptr;3、_tx_thread_current_ptr->TX_run_count++,_tx_timer_time_slice=_tx_thread_current_ptr->tx_time_slice;4、If线程堆栈的中断类型=1，restore Context_irq,elserestore Context_request;}Tx_tic.s用于开中断和关中断。
Unint _tx_thread_interrupt_control(unint new _posture){1、R1=CPSR;2、SWI；3、CPSR|=RO=new posture;4、R0=R1,R0为返回值；}移植该函数时，针对不同的处理器，应盖根据准热爱寄存器CPSR的中断禁止未来设置开关中断向量，主要修改TX_PORT.H中的TX_INT_ENABLE和TX_INT_DISABLE.R0用来传递的参数和结果。
Tx_tsb.s负责创建每个线程的初始堆栈结构，这个初始的结构在线程创建时会引起中断上下文返回到_tx_thread_shell_entry函数的开头。
然后这个函数调用指定线程入口函数。
其中断类型设置为1，表示中断上下文。
Void _tx_thread_stack_build(TXTHREAD *thread_ptr,void(*function)(void)){1、保证堆栈起始地址八字节对齐；2、中断地址存入线程调用的入口地址PUSHfunction_ptr;3、R0-R12,R14的初始值都设置为0，PUSH初始值；4、要存入堆栈的CPSR值设置为用户模式，开中断，标志位清零，R1=USER_MODE,PUSH R1;5、Thread_ptr->sp=new SP;}当处理一个低级的中断时，tx_tpc.s决定是否发生抢占，它是可选的，大多数端口都用不到。
TX_TIMIN.S负责处理定时中断。
这两个函数只要将它们翻译成相应ARM汇编语言就可以了。
threadx学习笔记（二）-1_tx_thread_schedule()。
VOID _tx_initialize_kernel_enter(VOID){/*确定编译器是否已经初始化过 */if(_tx_thread_system_state != TX_INITIALIZE_ALMOST_DONE){/* 没有初始化的话执行下面程序 *//* 设置系统状态变量来表示现正在处理过程中注意该变量在后边的中断嵌套中会使用*/_tx_thread_system_state = TX_INITIALIZE_IN_PROGRESS;/* 进行一些基本硬件设置，启动程序等 */_tx_initialize_low_level();/*进行一些高级的初始化*/_tx_initialize_high_level();}/*设置系统状态变量来表示现正在处理过程中注意该变量在后边的中断嵌套中会使用*/_tx_thread_system_state = TX_INITIALIZE_IN_PROGRESS;/* 调用初始化中提供的应用程序把第一个未使用的变量地址传送给它 */tx_application_define(_tx_initialize_unused_memory);/*设置系统壮伟进入线程调度做准备*/_tx_thread_system_state = TX_INITIALIZE_IS_FINISHED;/* 进入线程循环开始执行线程 */_tx_thread_schedule();}_tx_initialize_low_level()void tx_kernel_enter(void)所属文件调用者开关量tx_till.s 启动代码无该函数实现对FIQ、IRQ和SVC模式下的sp寄存器的初始化，并对定时堆栈的基地址、大小和定时优先级变量进行初始化。
/* 进行一些基本硬件设置，启动程序等 *//*该函数在文件tx_ill.s文件中*/_tx_initialize_low_level();;/* VOID _tx_initialize_low_level(VOID);{EXPORT _tx_initialize_low_level_tx_initialize_low_level; /* 保存系统堆栈指针. */;/* _tx_thread_system_stack_ptr = (VOID_PTR) A7 (SP); */;/*设置各个模式下的sp（堆栈指针）*/;/* We must be in SVC mode at this point! */;LDR a2,=|Image$$ZI$$Limit|; Get end of non-initialized RAM areaLDR a3,[pc,#FIQ_STACK_SIZE-.-8];获得FIO堆栈地址（这里没有弄明白，有待？）MOV a1,#FIQ_MODE ;设置FIQ_MODEMSR CPSR_c, a1 ;进入FIQ模式ADD a2, a2, a3 ;计算FIQ堆栈的开始BIC a2, a2,#3 ;将a2的低两位清零确保堆栈的的开始为long对齐SUB a2, a2,#4 ;往回退一个字MOV sp, a2 ;建立FIQ 堆栈指针（即FIQ模式的sp）MOV sl,#0 ; Clear sl（R10）MOV fp,#0 ; Clear fp(R11)LDR a3,[pc,#SYS_STACK_SIZE-.-8];获得 IRQ (system stack size)MOV a1,#IRQ_MODE ;建立IRQ模式的 CPSRMSR CPSR_c, a1 ;进入IRQ模式ADD a2, a2, a3 ;计算IRQ stack的开始BIC a2, a2,#3 ;将a2的低两位清零确保堆栈的的开始为long对齐SUB a2, a2,#4 ;往回退一个字MOV sp, a2 ;建立 IRQ 堆栈指针MOV a1,#SVC_MODE ;建立SVC模式的CPSRMSR CPSR_c, a1 ;进入 SVC模式LDR a4,[pc,#SYS_STACK_PTR-.-8];获得stack 指针STR a2,[a4,#0];保存系统堆栈;;/* Save the system stack pointer. */; _tx_thread_system_stack_ptr =(VOID_PTR)(sp);;LDR a2,[pc,#SYS_STACK_PTR-.-8];获得系统堆栈指针的地址LDR a1,[a2,#0];获得系统堆栈指针ADD a1, a1,#4 ;增加一个long长度;;/* Pickup the first available memory address. */;;/* Allocate space for the timer thread's stack. */; _tx_timer_stack_start = first_available_memory;; _tx_timer_stack_size = stack_size;; _tx_timer_priority = 0;;LDR a2,[pc,#TIMER_STACK-.-8];获得定时堆栈指针地址LDR a4,[pc,#TIMER_STACK_SIZE-.-8];获得定时堆栈大小地址LDR a3,[pc,#TIM_STACK_SIZE-.-8];获得实际定时堆栈大小STR a1,[a2,#0];将定时堆栈的基地址放在堆栈指针地址所对应的内存中STR a3,[a4,#0];存储定时器堆栈大小ADD a1, a1, a3 ;新的空内存地址LDR a2,[pc,#TIMER_PRIORITY-.-8];获得定时器优先级地址MOV a3,#0 ;获得定时器线程优先级STR a3,[a2,#0];存储定时器线程优先级;/*保存第一个变量内存地址. */;_tx_initialize_unused_memory =(VOID_PTR)System Stack+Timer Stack; ;LDR a3,[pc,#UNUSED_MEMORY-.-8];获得没有使用的内存指针地址STR a1,[a3,#0];保存第一个空内存地址;/* 建立周期性的定时中断. */STMDB {LR}//让lr入栈，保护lrBL TargetInit //Target Init（）为C语言编写的中断定时函数LDMIA {lr}//让lr出栈在这里加上ARM定时器已实现周期性的中断;/* Done, return to caller. */;MOV pc, lr ;Return to caller;}__tx_irq_handler所属文件调用者开关量tx_till.s IRQ中断无该函数是在定时中断后调用，该函数调用了_tx_thread_context_save函数（包含在tx_tcs.s中），该函数又调用到__tx_irq_processing_return函数处（包含在tx_till.s）EXPORT __tx_irq_handlerEXPORT __tx_irq_processing_return__tx_irq_handler;;/* 调用函数保存线程上下文环境. */B _tx_thread_context_save__tx_irq_processing_return;;/* At this point execution is still in the IRQ mode. The CPSR, pointof; interrupt, and all C scratch registers are available for use. In ; addition, IRQ interrupts may be re-enabled - with certain restrictions -; if nested IRQ interrupts are desired. Interrupts may be re-enabled over ; small code sequences where lr is saved before enabling interrupts and ; restored after interrupts are again disabled. */;;/* For debug purpose, execute the timer interrupt processing here. In ; a real system, some kind of status indication would have to be checked ; before the timer interrupt handler could be called. */;BL clearflag ;清除中断标志位很重要（自己移植时加的，位置是否恰当？）BL _tx_timer_interrupt ;定时中断处理函数;;/* 系统线程上下文环境恢复函数 */B _tx_thread_context_restore_tx_timer_interrupt所属文件调用者开关量tx_timin.s 启动代码无该函数主要是中断后将系统时钟加1，时间切片减1。