线程工厂ThreadFactory学习笔记
java_多线程_笔记
1.API1.Thread API1)Join:A线程调用B线程的Join方法，A线程阻塞，直至B线程执行完毕。
2)Thread（Runable target）：注意，参数target是对象实例。
ng.class :class类实例表示正在运行的java应用程序中的类和接口。
3.JDK提供的线程池ThreadPoolExecutor 线程池类，提供三种排队策略：1）直接提交。
线程池采用无界线程池，即线程池中的线程数量没有限制（无界线程池情况适用于，线程执行时间短，例如小于1秒，并发量高的场景），工作队列的默认选项是SynchronousQueue，它将任务直接提交给线程而不保持它们。
在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。
此策略可以避免在处理可能具有内部依赖性的请求集合时出现锁定。
直接提交通常要求无界maximumPoolSizes 以避免拒绝新提交的任务。
当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
2）无界队列，线程池数量固定，队列无限制。
使用无界队列（例如，不具有预定义容量的LinkedBlockingQueue）将导致在所有corePoolSize 线程都忙的情况下将新任务加入队列。
这样，创建的线程就不会超过corePoolSize。
（因此，maximumPoolSize 的值也就无效了。
）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在Web 页服务器中。
这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
3）有界队列，当使用有限的maximumPoolSizes 时，有界队列（如ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。
队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。
自定义线程池的七个参数
自定义线程池的七个参数自定义线程池是编程中常用的一种技术，它能够有效地管理和调度多线程任务，提高程序的并发性能和资源利用率。
在进行自定义线程池时，需要设置一些参数来配置线程池的行为，以满足特定需求。
下面是七个常见的参数及其相关参考内容。
1. 核心线程数（corePoolSize）：核心线程数是线程池中同时运行的最小线程数目，即使线程池中没有任务可执行，核心线程也会一直存在。
可以根据系统的负载和性能需求来确定核心线程数。
参考内容：- 根据任务的类型和预估的并发量，设置足够的核心线程数，以保证任务能够及时执行。
- 考虑 CPU 核心数和内存等硬件资源的限制，避免设置过多的核心线程数，导致线程上下文切换频繁。
2. 最大线程数（maximumPoolSize）：最大线程数是线程池中允许的最大线程数目，当线程池中的线程数量达到最大线程数后，如果任务继续增加，线程池会根据拒绝策略来处理。
参考内容：- 根据实际需求和预估的最大并发量来设置最大线程数，以充分利用系统资源。
- 合理评估系统的承载能力和瓶颈，避免设置过多的最大线程数，导致系统资源耗尽。
3. 线程空闲时间（keepAliveTime）：线程空闲时间是在线程池中的线程执行完一个任务后，如果在一段时间内没有新任务到达，那么该线程是否继续保留并等待新任务的时间。
参考内容：- 根据任务的响应时间和系统的负载情况，设置合适的线程空闲时间，以避免频繁地创建和销毁线程，提高线程池的利用率。
- 合理评估任务的到达频率和处理时间，避免线程空闲时间过短或过长，影响线程池的性能。
4. 阻塞队列（workQueue）：阻塞队列用于存储待执行的任务，当线程池中的线程数达到核心线程数时，新的任务会被放入阻塞队列中，待有可用线程时再执行。
参考内容：- 根据任务的特性和数量，选择合适的阻塞队列，如ArrayBlockingQueue、LinkedBlockingQueue 等。
- 考虑队列的容量和内存资源，避免过大的队列导致内存溢出，或过小的队列导致任务被丢弃。
basicthreadfactory asynctaskexecutor 使用
basicthreadfactory asynctaskexecutor 使用摘要：1.基本线程工厂（BasicThreadFactory）简介2.异步任务执行器（AsyncTaskExecutor）概述3.基本线程工厂与异步任务执行器的结合使用4.实例演示5.总结与建议正文：在过去的一些年里，线程池和异步任务执行器在Android 开发中变得越来越重要。
基本线程工厂（BasicThreadFactory）和异步任务执行器（AsyncTaskExecutor）是Android 框架中提供的两个用于处理并发任务的类。
本文将介绍这两个类的基本概念，以及如何将它们结合使用以提高应用程序的性能。
1.基本线程工厂（BasicThreadFactory）简介基本线程工厂是一个用于创建线程的简单接口。
它提供了一个用于创建新线程的默认实现，该实现可以根据给定的线程名和线程优先级创建线程。
在Android 开发中，基本线程工厂常用于在后台线程中执行耗时任务，以避免阻塞主线程。
2.异步任务执行器（AsyncTaskExecutor）概述异步任务执行器是一个更高层次的线程管理类，它允许您在后台线程中执行任务，而无需显式创建和管理线程。
异步任务执行器为您处理线程启动、停止和任务调度等方面的问题。
AsyncTaskExecutor 主要有以下几个优点：- 自动根据任务大小调整线程池大小，以避免内存泄漏和过度消耗系统资源。
- 支持任务的取消和挂起操作。
- 能够在任务执行前后设置执行策略，例如执行前等待、执行超时等。
3.基本线程工厂与异步任务执行器的结合使用在实际开发中，您可以将基本线程工厂与异步任务执行器结合使用，以实现更高效的任务执行。
以下是一个简单的实例演示：```java// 创建一个基本线程工厂实例BasicThreadFactory threadFactory = new BasicThreadFactory(Looper.getMainLooper());// 创建一个异步任务执行器实例AsyncTaskExecutor executor = new AsyncTaskExecutor();executor.setThreadFactory(threadFactory);// 提交一个异步任务executor.submit(new Runnable() {@Overridepublic void run() {// 这里是任务执行的代码}});// 停止异步任务执行器executor.shutdown();```4.实例演示在这个示例中，我们首先创建了一个基本线程工厂实例，然后用它来设置异步任务执行器的线程工厂。
Java学习笔记之--线程
1.一个进程包含多个线程，每一个线程都有相对独立的资源、生存周期。
在进程中，可以有一个或多个线程，如果程序员不创建线程对象，那么系统会自动创建一个主线程。
2.进程是同时进行的，每个进程都都独立的地址空间，而线程是分时进行的，他们共用地址空间，并且分享同一个进程，但由于执行速度很快，所以感觉不出来，感觉好像是线程也同时进行一样。
3.线程有五种状态：新建、就绪、运行、阻塞和死亡。
4.创建线程可以通过继承Thread类来完成。
Thread类的构造方法：Thread类的常用方法：5.利用Thread的子类创建线程package aaa;public class myThread extends Thread {private static int count=0;public myThread(String name) {super(name);}public void run(){int i=0;for(i=0;i<100;i++){count=count+1;System.out.println("my name is"+getName()+"count="+count);//其中getName()是Thread中的方法，用于返回现在正在运行的线程的名字try {sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args){myThread first,second;first=new myThread("First Thread");second=new myThread("Second Thread");first.start();second.start();//其实两个线程是同时启动的。
RTThread学习笔记——对线程的个人了解
RTThread学习笔记——对线程的个⼈了解线程？它是啥？ 在我们刚开始进⼊嵌⼊式软件的编程领域时，每次都会接触到⼀个函数——main函数，在裸机的编程中，程序的执⾏流程就是在main 函数中进⾏的，main函数也可以理解为⼀个线程，它也有它的栈空间来存储变量。
但是，如果有许多线程呢，怎样来区分它们？⼜怎样来分配存储空间？ 对于这个问题，RTThread有它的解决办法。
⾸先是线程栈 栈，是⼀种经典的储存结构，RTThread为每个线程都分配了栈空间，来看看它是怎样定义的。
ALIGN(RT_ALIGN_SIZE) //线程栈对齐static rt_uint8_t rt_led1_thread_stack[1024]; //定义线程栈 这是⼀个rt_uint8_t（RTThread中的宏定义，⽆符号8位）类型的全局数组，第⼀句话是为了栈空间对齐，使得CPU对数据的访问更加⾼效，第⼆句就是线程的具体定义了，这⾥定义1024的长度。
然后是线程的ID卡——线程控制块 在操作系统中，常常有许多的线程在运⾏，⾯对着这么多的的线程，⾃然需要⼀个⾝份块来标识每个线程，使得系统便于管理。
⽽这个⾝份，就是线程控制块。
具体定义如下：struct rt_thread{/* rt object */char name[RT_NAME_MAX]; /**< the name of thread */rt_uint8_t type; /**< type of object */rt_uint8_t flags; /**< thread's flags */#ifdef RT_USING_MODULEvoid *module_id; /**< id of application module */#endifrt_list_t list; /**< the object list */rt_list_t tlist; /**< the thread list *//* stack point and entry */void *sp; /**< stack point */void *entry; /**< entry */void *parameter; /**< parameter */void *stack_addr; /**< stack address */rt_uint32_t stack_size; /**< stack size *//* error code */rt_err_t error; /**< error code */rt_uint8_t stat; /**< thread status *//* priority */rt_uint8_t current_priority; /**< current priority */rt_uint8_t init_priority; /**< initialized priority */#if RT_THREAD_PRIORITY_MAX > 32rt_uint8_t number;rt_uint8_t high_mask;#endifrt_uint32_t number_mask;#if defined(RT_USING_EVENT)/* thread event */rt_uint32_t event_set;rt_uint8_t event_info;#endif#if defined(RT_USING_SIGNALS)rt_sigset_t sig_pending; /**< the pending signals */rt_sigset_t sig_mask; /**< the mask bits of signal */void *sig_ret; /**< the return stack pointer from signal */rt_sighandler_t *sig_vectors; /**< vectors of signal handler */void *si_list; /**< the signal infor list */#endifrt_ubase_t init_tick; /**< thread's initialized tick */rt_ubase_t remaining_tick; /**< remaining tick */struct rt_timer thread_timer; /**< built-in thread timer */void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit *//* light weight process if present */#ifdef RT_USING_LWPvoid *lwp;#endifrt_uint32_t user_data; /**< private user data beyond this thread */}; 看起来线程控制块的定义⾮常复杂，实际上，线程控制块的主要包含信息有对象成员相关（RTT(hread)通过对象来进⾏管理），线程链表相关（RTT通过线程链表实现调度，也被称为优先级表/就绪链表），线程栈相关和线程本⾝的相关地址。
java多线程学习基础篇（三）Thread类的常用方法
java多线程学习基础篇（三）Thread类的常⽤⽅法线程Thread是⼀个程序的多个执⾏路径，执⾏调度的单位，依托于进程存在。
线程不仅可以共享进程的内存，⽽且还拥有⼀个属于⾃⼰的内存空间，这段内存空间也叫做线程栈，是在建⽴线程时由系统分配的，主要⽤来保存线程内部所使⽤的数据，如线程执⾏函数中所定义的变量。
Java中的多线程是⼀种抢占机制⽽不是分时机制。
抢占机制指的是有多个线程处于可运⾏状态，但是只允许⼀个线程在运⾏，他们通过竞争的⽅式抢占CPU。
下⾯介绍⼀些常⽤的Thread⽅法。
Thread.join()：静态⽅法，返回对当前正在执⾏的线程对象的引⽤在很多情况下，主线程⽣成并起动了⼦线程，如果⼦线程⾥要进⾏⼤量的耗时的运算，主线程往往将于⼦线程之前结束，但是如果主线程处理完其他的事务后，需要⽤到⼦线程的处理结果，也就是主线程需要等待⼦线程执⾏完成之后再结束，这个时候就要⽤到join()⽅法了。
Join⽅法实现是通过wait（⼩提⽰：Object 提供的⽅法）。
当main线程调⽤t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调⽤该对象的wait(等待时间)，直到该对象唤醒main线程，⽐如退出后。
这就意味着main 线程调⽤t.join时，必须能够拿到线程t对象的锁。
join() ⼀共有三个重载版本，分别是⽆参、⼀个参数、两个参数：public final void join() throws InterruptedException; //⽆参数的join()等价于join(0),作⽤是⼀直等待该线程死亡public final synchronized void join(long millis) throws InterruptedException; //最多等待该线程死亡millis毫秒public final synchronized void join(long millis, int nanos) throws InterruptedException; //最多等待该线程死亡millis毫秒加nanos纳秒(1) 三个⽅法都被final修饰，⽆法被⼦类重写。
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模式下对应的是不同的物理寄存器，所以若要得到中断前的线程堆栈指针，需要先返回到该线程的运行模式，同时禁止中断，取值后再返回到终端模式。
线程池的七大核心参数
线程池的七大核心参数1. 前言在并发编程中，使用线程池来管理线程的执行已成为常见的做法。
线程池可以提高系统的资源利用率，降低线程创建和销毁的开销，并且根据系统负载自动调整线程数量。
要理解和掌握线程池的使用，首先要了解它的七大核心参数。
2. 核心参数概述线程池的七大核心参数包括：1.核心线程数（corePoolSize）2.最大线程数（maximumPoolSize）3.空闲线程等待时间（keepAliveTime）4.时间单位（unit）5.任务队列（workQueue）6.线程工厂（threadFactory）7.饱和策略（handler）接下来，我们将详细解释每个参数的作用和设置方法。
3. 核心线程数核心线程数是线程池中最小的线程数量。
即使没有任务需要执行，核心线程也会一直存在。
核心线程数的设置需要根据系统负载和资源情况来决定。
如果系统负载较高，可以适当增加核心线程数，以提高并发处理能力。
4. 最大线程数最大线程数是线程池中能存在的最大线程数量。
当任务数量超过核心线程数且任务队列已满时，线程池会创建新的线程，直到达到最大线程数。
最大线程数的设置需要考虑系统资源的限制，避免过度创建线程导致系统资源耗尽。
5. 空闲线程等待时间空闲线程等待时间指的是当线程池中的线程没有任务可执行时，空闲线程的最大存活时间。
如果超过这个时间，空闲线程将会被销毁。
设置合适的空闲线程等待时间可以避免线程池中线程过多导致资源浪费。
6. 时间单位时间单位用于设置空闲线程等待时间的单位，常见的时间单位有秒、毫秒、微秒等。
根据具体需求选择合适的时间单位。
7. 任务队列任务队列用于存放还未被执行的任务。
当线程池中的线程都在执行任务时，新的任务会被放入任务队列等待执行。
常见的任务队列有有界队列（如ArrayList）和无界队列（如LinkedBlockingQueue）。
有界队列可以避免任务堆积过多，但可能会导致任务执行的延迟。
而无界队列可以保证所有的任务都得到执行，但可能会消耗过多的内存。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
线程工厂ThreadFactory学习笔记
线程工厂是一个接口，它用于根据需要创建新线程的对象。
使用线程工厂就无需再手工编写对new Thread 的调用了，从而允许应用程序使用特殊的线程子类、属性等等。
此接口最简单的实现就是：
Executors.defaultThreadFactory()方法提供了更有用的简单实现，它返回用于创建新线程的默认线程工厂。
此工厂创建同一ThreadGroup中Executor 使用的所有新线程。
如果有SecurityManager，则它使用System.getSecurityManager()组来调用此defaultThreadFactory 方法，其他情况则使用线程组。
每个新线程都作为非守护程序而创建，并且具有设置为Thread.NORM_PRIORITY 中较小者的优先级以及线程组中允许的最大优先级。
新线程具有可通过pool-N-thread-M的Thread.getName()来访问的名称，其中N是此工厂的序列号，M是此工厂所创建线程的序列号。
DefaultThreadFactory的源码如下所示：
/**
* The default thread factory
*/
static class DefaultThreadFactory implements ThreadFactory{
static final AtomicInteger poolNumber =new AtomicInteger(1);
final ThreadGroup group;
final AtomicInteger threadNumber=new AtomicInteger(1);
final String namePrefix;
DefaultThreadFactory(){
SecurityManager s =System.getSecurityManager();
group=(s !=null)? s.getThreadGroup():
Thread.currentThread().getThreadGroup();
namePrefix="pool-"+
poolNumber.getAndIncrement()+
"-thread-";
}
public Thread newThread(Runnable r){
Thread t =new Thread(group, r,
这里需要注意一点，就是该线程工厂所创建的线程，都是非守护线程，整个进程需要全部线程都处理完毕，才会被关闭。