简答题实现runnable接口创建线程并在线程内提示线程名称等相关信息

实现Runnable接口创建线程的步骤如下：

1定义一个类，实现Runnable接口。

public class MyRunnable implements Runnable {

// 线程执行体

@Override

public void run() {

// 提示线程名称等相关信息

Systemoutprintln("线程名称：" + ThreadcurrentThread()getName());

Systemoutprintln("线程ID：" + ThreadcurrentThread()getId());

Systemoutprintln("线程状态：" + ThreadcurrentThread()getState());

}

}

2、创建Runnable接口实现类的实例。

MyRunnable runnable = new MyRunnable();

3、创建Thread类的实例，并将Runnable接口实现类的实例作为参数传递给Thread类的构造方法。

Thread thread = new Thread(runnable);

4、调用Thread类的start()方法启动线程。

threadstart();

在线程内提示线程名称等相关信息，可以在Runnable接口实现类的run()方法中使用Thread类的currentThread()方法来获取当前线程的信息，然后通过getName()、getId()和getState()方法来获取线程名称、线程ID和线程状态，并打印到控制台。

public class Main {    public static void main(String[] args) {    

// 创建Runnable接口实现类的实例

     

MyRunnable runnable = new MyRunnable();    

// 创建Thread类的实例，并将Runnable接口实现类的实例作为参数传递给Thread类的构造方法

Thread thread = new Thread(runnable);

// 调用Thread类的start()方法启动线程

threadstart();

}

}

class MyRunnable implements Runnable {

// 线程执行体

@Override

public void run() {

// 提示线程名称等相关信息

Systemoutprintln("线程名称：" + ThreadcurrentThread()getName());

Systemoutprintln("线程ID：" + ThreadcurrentThread()getId());

Systemoutprintln("线程状态：" + ThreadcurrentThread()getState());

}

}

在C#中，线程对象Thread使用ThreadState属性指示线程状态，它是带Flags特性的枚举类型对象。ThreadState为线程定义了一组所有可能的执行状态。一旦线程被创建，它就至少处于其中一个状态中，直到终止。在公共语言运行时中创建的线程最初处于Unstarted状态中，而进入运行时的外部线程则已经处于Running状态中。通过调用Start可以将Unstarted线程转换为Running状态。并非所有的ThreadState值的组合都是有效的。例如，线程不能同时处于Aborted和Unstarted状态中。因此判断线程当前的状态必须用bitmask按位运算来达到判断目的，不能直接使用相等来判断。

1、判断线程是否处于取消状态(MyThreadThreadState&ThreadStateAbortRequested)。=0。

2、判断线程是否处于运行状态(MyThreadThreadState==ThreadStateRunning)。

       传统的多线程是通过继承Thread类及实现Runnable接口来实现的，每次创建及销毁线程都会消耗资源、响应速度慢，且线程缺乏统一管理，容易出现阻塞的情况，针对以上缺点，线程池就出现了。

       线程池是一个创建使用线程并能保存使用过的线程以达到复用的对象，简单的说就是一块缓存了一定数量线程的区域。

       1复用线程：线程执行完不会立刻退出，继续执行其他线程；

       2管理线程：统一分配、管理、控制最大并发数；

       1降低因频繁创建&销毁线程带来的性能开销，复用缓存在线程池中的线程；

       2提高线程执行效率&响应速度，复用线程：响应速度；管理线程：优化线程执行顺序，避免大量线程抢占资源导致阻塞现象；

       3提高对线程的管理度；

       线程池的使用也比较简单，流程如下：

       接下来通过源码来介绍一下ThreadPoolExecutor内部实现及工作原理。

       线程池的最终实现类是ThreadPoolExecutor，通过实现可以一步一步的看到，父接口为Executor:

       其他的继承及实现关系就不一一列举了，直接通过以下图来看一下：

       从构造方法开始看：

       通过以上可以看到，在创建ThreadPoolExecutor时，对传入的参数是有要求的：corePoolSize不能小于0；maximumPoolSize需要大于0，且需要大于等于corePoolSize；keepAliveTime大于0；workQueue、threadFactory都不能为null。

       在创建完后就需要执行Runnable了，看以下execute()方法：

       在execute()内部主要执行的逻辑如下：

       分析点1：如果当前线程数未超过核心线程数，则将runnable作为参数执行addWorker()，true表示核心线程，false表示非核心线程；

       分析点2：核心线程满了，如果线程池处于运行状态则往workQueue队列中添加任务，接下来判断是否需要拒绝或者执行addWorker()；

       分析点3：以上都不满足时 [corePoolSize=0且没有运行的线程，或workQueue已经满了] ，执行addWorker()添加runnable，失败则执行拒绝策略；

        总结一下：线程池对线程创建的管理，流程图如下：

       在执行addWorker时，主要做了以下两件事：

       分析点1：将runnable作为参数创建Worker对象w，然后获取w内部的变量thread；

       分析点2：调用start()来启动thread；

       在addWorker()内部会将runnable作为参数传给Worker，然后从Worker内部读取变量thread，看一下Worker类的实现：

       Worker实现了Runnable接口，在Worker内部，进行了赋值及创建 *** 作，先将execute()时传入的runnable赋值给内部变量firstTask，然后通过ThreadFactorynewThread(this)创建Thread，上面讲到在addWorker内部执行tstart()后，会执行到Worker内部的run()方法，接着会执行runWorker(this)，一起看一下：

       前面可以看到，runWorker是执行在子线程内部，主要执行了三件事：

       分析1：获取当前线程，当执行shutdown()时需要将线程interrupt()，接下来从Worker内部取到firstTask，即execute传入的runnable，接下来会执行；

       分析2：while循环，task不空直接执行；否则执行getTask()去获取，不为空直接执行；

       分析3：对有效的task执行run()，由于是在子线程中执行，因此直接run()即可，不需要start()；

       前面看到，在while内部有执行getTask()，一起看一下：

       getTask()是从workQueue内部获取接下来需要执行的runnable，内部主要做了两件事：

       分析1：先获取到当前正在执行工作的线程数量wc，通过判断allowCoreThreadTimeOut[在创建ThreadPoolExecutor时可以进行设置]及wc > corePoolSize来确定timed值；

       分析2：通过timed值来决定执行poll()或者take()，如果WorkQueue中有未执行的线程时，两者作用是相同的，立刻返回线程；如果WorkQueue中没有线程时，poll()有超时返回，take()会一直阻塞；如果allowCoreThreadTimeOut为true，则核心线程在超时时间没有使用的话，是需要退出的；wc > corePoolSize时，非核心线程在超时时间没有使用的话，是需要退出的；

       allowCoreThreadTimeOut是可以通过以下方式进行设置的：

       如果没有进行设置，那么corePoolSize数量的核心线程会一直存在。

        总结一下：ThreadPoolExecutor内部的核心线程如何确保一直存在，不退出？

       上面分析已经回答了这个问题，每个线程在执行时会执行runWorker()，而在runWorker()内部有while()循环会判断getTask()，在getTask()内部会对当前执行的线程数量及allowCoreThreadTimeOut进行实时判断，如果工作数量大于corePoolSize且workQueue中没有未执行的线程时，会执行poll()超时退出；如果工作数量不大于corePoolSize且workQueue中没有未执行的线程时，会执行take()进行阻塞，确保有corePoolSize数量的线程阻塞在runWorker()内部的while()循环不退出。

       如果需要关闭线程池，需要如何 *** 作呢，看一下shutdown()方法：

       以上可以看到，关闭线程池的原理：a 遍历线程池中的所有工作线程；b 逐个调用线程的interrupt()中断线程（注：无法响应中断的任务可能永远无法终止）

       也可调用shutdownNow()来关闭线程池，二者区别：

       shutdown()：设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程；

       shutdownNow()：设置线程池的状态为STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表；

       使用建议：一般调用shutdown()关闭线程池；若任务不一定要执行完，则调用shutdownNow()；

        总结一下：ThreadPoolExecutor在执行execute()及shutdown()时的调用关系，流程图如下：

       线程池可以通过Executors来进行不同类型的创建，具体分为四种不同的类型，如下：

       可缓存线程池：不固定线程数量，且支持最大为IntegerMAX_VALUE的线程数量：

       1、线程数无限制

       2、有空闲线程则复用空闲线程，若无空闲线程则新建线程

       3、一定程度上减少频繁创建/销毁线程，减少系统开销

       固定线程数量的线程池：定长线程池

       1、可控制线程最大并发数(同时执行的线程数)

       2、超出的线程会在队列中等待。

       单线程化的线程池：可以理解为线程数量为1的FixedThreadPool

       1、有且仅有一个工作线程执行任务

       2、所有任务按照指定顺序执行，即遵循队列的入队出队规则

       定时以指定周期循环执行任务

       一般来说，等待队列 BlockingQueue 有: ArrayBlockingQueue 、 LinkedBlockingQueue 与 SynchronousQueue 。

       假设向线程池提交任务时，核心线程都被占用的情况下:

        ArrayBlockingQueue ：基于数组的阻塞队列，初始化需要指定固定大小。

       当使用此队列时，向线程池提交任务，会首先加入到等待队列中，当等待队列满了之后，再次提交任务，尝试加入队列就会失败，这时就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。所以最终可能出现后提交的任务先执行，而先提交的任务一直在等待。

        LinkedBlockingQueue ：基于链表实现的阻塞队列，初始化可以指定大小，也可以不指定。

       当指定大小后，行为就和 ArrayBlockingQueue一致。而如果未指定大小，则会使用默认的 IntegerMAX_VALUE 作为队列大小。这时候就会出现线程池的最大线程数参数无用，因为无论如何，向线程池提交任务加入等待队列都会成功。最终意味着所有任务都是在核心线程执行。如果核心线程一直被占，那就一直等待。

        SynchronousQueue ：无容量的队列。

       使用此队列意味着希望获得最大并发量。因为无论如何，向线程池提交任务，往队列提交任务都会失败。而失败后如果没有空闲的非核心线程，就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。完全没有任何等待，唯一制约它的就是最大线程数的个数。因此一般配合IntegerMAX_VALUE就实现了真正的无等待。

       但是需要注意的是， 进程的内存是存在限制的，而每一个线程都需要分配一定的内存。所以线程并不能无限个。

最早知道ThreadLocal是在Looper的源码里，用一个ThreadLocal保存了当前的looper对象。

当时就查了下ThreadLocal，发现是保存线程私有对象的容器，以为就是一个类似hashmap，用线程做key，存value。最近看了下并不是如此，实际上是以ThreadLocal自身为key来存储对象的。于是来学习下ThreadLocal源码是如何做到保存线程私有对象的。

ThreadLocal、ThreadLocalMap、Thread之间的关系和我们下意识中想的不太一样，不过一步步看下去之后就能明白为啥ThreadLocal能保存线程私有对象了。

这个是Thread源码，每一个Thread都有一个ThreadLocalMap对象，而ThreadLocalMap是ThreadLocal的内部类，是实际存储对象的容器。

基本关系知道了，最后再来看看ThreadLocal的方法：

那么现在基本完全清楚ThreadLocal与Thread还有ThreadLocalMap之间的关系了。

每个Thread都有一个成员变量ThreadLocalMap。这个ThreadLocalMap对象不是public，所以外部调用不了，可以看做是线程私有对象。

ThreadLocalMap存了一个table，table里保存了一些entry，每个entry对应一个key和value，而这个key就是ThreadLocal对象。

因此一个ThreadLocal只能存一个value，但是可以通过new多个ThreadLocal来保存多个线程私有对象。

在上面的源码中我们看到Entry里持有的ThreadLocal对象是弱引用持有，因此ThreadLocal不会因为线程持有而泄露，比如我们Android的主线程，正常使用过程中是不会挂掉的。

但是Enrty的value的是强引用的，因此ThreadLocal中的value还是会因为线程持有而无法回收。如果继续看源码的话，会发现在ThreadLocalMap的resize和expungeStaleEntry方法里会检查key为空的value值为空帮助GC。

因此为了避免value内存泄露，我们需要在ThreadLocal不需要的时候主动remove掉。

ThreadLocal通过自身的threadLocalHashCode来碰撞得到自己在ThreadLocalMap的table里的索引i。因此这个threadLocalHashCode就十分重要了。

这里需要保证threadLocalHashCode是唯一的，否则两个线程同时创建ThreadLocal得到相同的hashcode，那就破坏了ThreadLocalMap的线程私有特性了。

这里生成threadLocalHashCode是通过一个静态对象nextHashCode不断增加来获得的。那怎么保证多个进程并发实例化ThreadLocal对象，不会生成相同的hashcode呢？

答案是AtomicInteger，通过这个类来保证变量自增 *** 作在多线程 *** 作时候的原子性。

我们知道Synchronized也可以保证原子性，但相比于它，AtomicInteger类是通过非阻塞方法来实现原子性的，需要的性能开销更小。

这种非阻塞实现原子性的方法和处理器的CAS指令有关，感兴趣的小伙伴自行研究吧~

获取线程名字这件事情本质上和Runnable是没有关系的。一个Runnable可以给多个线程去运行，所以如果在这个概念上你有误解的话，希望重新考虑一下。

另外，在任何时候，你都可以用ThreadcurrentThread()getName()来获取当前线程的名字

tthreadLocals 是当前线程Thread（t） 的成员变量， 当使用 ThreadLocal 创建对象后，调用 ThreadLocalset(）方法会看到初始化 ThreadLocalMap的过程，JDK内部实现代码截图如下:

（1）调用set方法，初始化 ThreadLocalMap 对象，如果getMap(t)获取当前线程 threadLocals 变量为空，随后创建一个；反之，直接使用存储线程数据

（2）创建ThreadLocalMap 对象的方法实现，即为当前线程 threadLocals赋值

ThreadLocal的作用是什么？使用时有哪些注意事项？为什么ThreadLocalMap中的Entry要使用WeakReference？netty中FastThreadLocal又做了什么优化？ 答案尽在本文中。

用ThreadLocal修饰的变量，一般我们称为线程本地变量。那么一般什么情况下会使用ThreadLocal呢？

ThreadLocal提供的方法有get(),set(T value), remove()，并且有一个可以override的initialValue()方法。

一般我们定义ThreadLocal变量都定义成static final的变量，然后就可以通过这个ThreadLocal变量进行get set了。

了解了ThreadLocal的作用后，我们开始分析一下内部实现。

首先，每个线程Thread对象内有一个ThreadLocalMap类型的threadLocals字段，里面保存着key为ThreadLocal到value为Object的映射。

ThreadLocal的get,set,remove方法都是通过 *** 作当前线程内的ThreadLocalMap字段实现的， *** 作的key为自己(this)

上面的ThreadLocal的实现中大部分都是对ThreadLocalMap的 *** 作封装，那么ThreadLocalMap是怎么实现的呢？ ThreadLocalMap是ThreadLocal类的静态内部类。

ThreadLocalMap和HashMap有所不同，ThreadLocalMap使用线性探查法而不是拉链法解决hash冲突问题。

线性探查法可以用一个小例子来理解，想象一个停车场的场景，停车场中有一排停车位，停车时，会计算车子的hashCode算出在停车位中的序号，停上去，如果那个车位有车了， 则尝试停到它的下一个车位，如果还有车则继续尝试，到末尾之后从头再来。当取车时，则按照hashCode去找车，找到对应的位置后，要看一下对应的车位上是不是自己的车，如果不是， 尝试找下一个车位，如果找到了自己的车，则说明车存在，如果遇到车位为空，说明车不在。要开走车时，不光是简单开走就可以了，还得把自己车位后面的车重新修改车位，因为那些车可能因为 hash冲突更换了位置，修改车位的范围是当前位置到下一个为空的车位位置。当然还有扩容的情况，后面代码里会具体介绍。

那么为什么使用线性探测法而不是链表法呢？主要是因为数组结构更节省内存空间，并且一般ThreadLocal变量不会很多，通过0x61c88647这个黄金分割的递增hashCode也能比较好的分布在数组上减少冲突。

Map中的元素用一个Entry类表示，Entry包含了对ThreadLocal的WeakReference，以及对ThreadLocal值的强引用。

下面用一段代码来阐述一下。

我们创建了一个People类，并且创建了一个类型为ThreadLocal的实例字段，我们在main方法中连续调用say()方法，会发现打印出来的threadLocal的值是不一样的，虽然我们这些调用都在 同一个线程中，但是因为每次调用的ThreadLocal对象是不同的，也就是ThreadLocalMap的key不相同。如果我们把ThreadLocal字段加上static，就会发现打印出来的都是相同的值了。 长时间运行的线程是有可能出现的，比如tomcat的>

以上就是关于简答题实现runnable接口创建线程并在线程内提示线程名称等相关信息全部的内容，包括:简答题实现runnable接口创建线程并在线程内提示线程名称等相关信息、查看当前线程运行在哪个核上c#、Android线程池ThreadPoolExecutor详解等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！