创建java线程池

Ⅰ 如何创建并运行java线程

1
2
3
4
5
6
7
8
9
10
11

创建线程，就是这样
extends Thread 或者 implements Runnable，但是有很多问题；

所以引申出了下面的线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，
若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

Ⅱ 什么是java线程池

多线程是为了能够让计算机资源合理的分配，对于处理不同的任务创建不同的线程进行处理，但是计算机创建一个线程或者销毁一个线程所花费的也是比较昂贵的，有时候需要同时处理的事情比较多，就需要我们频繁的进行线程的创建和销毁，这样花费的时间也是比较多的。为了解决这一问题，我们就可以引用线程池的概念。
所谓线程池就是将线程集中管理起来，当需要线程的时候，可以从线程池中获取空闲的线程，这样可以减少线程的频繁创建与销毁，节省很大的时间和减少很多不必要的操作。
在java中提供了ThreadPoolExecutor类来进行线程的管理，这个类继承于AbstractExecutorService，而AbstractExecutorService实现了ExecutorService接口，我们可以使用ThreadPoolExecutor来进行线程池的创建。
在ThreadPoolExecutor的构造方法中，有多个参数，可以配置不同的参数来进行优化。这个类的源码构造方法为：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)其中每个参数代表的意义分别为
corePoolSize : 线程池中的核心线程数量，当线程池中当前的线程数小于这个配置的时候，如果有一个新的任务到来，即使线程池中还存在空闲状态的线程，程序也会继续创建一个新的线程放进线程池当中
maximumPoolSize: 线程池中的线程最大数量
keepAliveTime：当线程池中的线程数量大于配置的核心线程数量(corePoolSize)的时候，如果当前有空闲的线程，则当这个空闲线程可以存在的时间，如果在keepAliveTime这个时间点内没有新的任务使用这个线程，那么这个线程将会结束,核心线程不会结束，但是如果配置了allowCoreThreadTimeOut = true，则当空闲时间超过keepAliveTime之后，线程也会被结束调，默认allowCoreThreadTimeOut = false，即表示默认情况下，核心线程会一直存在于线程池当中。
unit : 空闲线程保持连接时间(keepAliveTime)的时间单位
workQueue：阻塞的任务队列，用来保存等待需要执行的任务。
threadFactory ：线程工厂，可以根据自己的需求去创建线程的对象，设置线程的名称，优先级等属性信息。
handler：当线程池中存在的线程数超过设置的最大值之后，新的任务就会被拒绝，可以自己定义一个拒绝的策略，当新任务被拒绝之后，就会使用hander方法进行处理。
在java中也提供了Executors工具类，在这个工具类中提供了多个创建线程池的静态方法，其中包含newCachedThreadPool、newFixedThreadPool、newScheledThreadPool、newSingleThreadExecutor等。但是他们每个方法都是创建了ThreadPoolExecutor对象，不同的是，每个对象的初始 参数值不一样;

Ⅲ java创建线程池有哪些

ava通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,
LIFO,
优先级)执行。

Ⅳ java常用的几种线程池实例讲解

下面给你介绍4种线程池：

1、newCachedThreadPool：

• 底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)

• 通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。

• 适用：执行很多短期异步的小程序或者负载较轻的服务器

2、newFixedThreadPool：

• 底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueue<Runnable>()无解阻塞队列

• 通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)

• 适用：执行长期的任务，性能好很多

3、newSingleThreadExecutor

• 底层：包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueue<Runnable>()无解阻塞队列

• 通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)

• 适用：一个任务一个任务执行的场景

4、NewScheledThreadPool:

• 底层：创建ScheledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；workQueue为：new DelayedWorkQueue()一个按超时时间升序排序的队列

• 通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构

• 适用：周期性执行任务的场景

最后给你说一下线程池任务执行流程：

• 当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。

• 当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行

• 当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务

• 当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理

• 当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程

• 当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭

Ⅳ java线程池怎么实现

要想理解清楚java线程池实现原理，明白下面几个问题就可以了：

(1)：线程池存在哪些状态，这些状态之间是如何进行切换的呢？

(2)：线程池的种类有哪些？

(3)：创建线程池需要哪些参数，这些参数的具体含义是什么？

(4)：将任务添加到线程池之后运行流程？

(5)：线程池是怎么做到重用线程的呢？

(6)：线程池的关闭

首先回答第一个问题：线程池存在哪些状态；

查看ThreadPoolExecutor源码便知晓：

[java]view plain

• //runStateisstoredinthehigh-orderbits

• privatestaticfinalintRUNNING=-1<<COUNT_BITS;

• privatestaticfinalintSHUTDOWN=0<<COUNT_BITS;

• privatestaticfinalintSTOP=1<<COUNT_BITS;

• privatestaticfinalintTIDYING=2<<COUNT_BITS;

• =3<<COUNT_BITS;

存在5种状态：

<1>Running：可以接受新任务，同时也可以处理阻塞队列里面的任务；

<2>Shutdown：不可以接受新任务，但是可以处理阻塞队列里面的任务；

<3>Stop：不可以接受新任务，也不处理阻塞队列里面的任务，同时还中断正在处理的任务；

<4>Tidying：属于过渡阶段，在这个阶段表示所有的任务已经执行结束了，当前线程池中是不存在有效的线程的，并且将要调用terminated方法；

<5>Terminated：终止状态，这个状态是在调用完terminated方法之后所处的状态；

那么这5种状态之间是如何进行转换的呢？查看ThreadPoolExecutor源码里面的注释便可以知道啦：

[java]view plain

• *RUNNING->SHUTDOWN

• *Oninvocationofshutdown(),perhapsimplicitlyinfinalize()

• *(RUNNINGorSHUTDOWN)->STOP

• *OninvocationofshutdownNow()

• *SHUTDOWN->TIDYING

• *Whenbothqueueandpoolareempty

• *STOP->TIDYING

• *Whenpoolisempty

• *TIDYING->TERMINATED

• *Whentheterminated()hookmethodhascompleted

从上面可以看到，在调用shutdown方法的时候，线程池状态会从Running转换成Shutdown；在调用shutdownNow方法的时候，线程池状态会从Running/Shutdown转换成Stop；在阻塞队列为空同时线程池为空的情况下，线程池状态会从Shutdown转换成Tidying；在线程池为空的情况下，线程池状态会从Stop转换成Tidying；当调用terminated方法之后，线程池状态会从Tidying转换成Terminate；

在明白了线程池的各个状态以及状态之间是怎么进行切换之后，我们来看看第二个问题，线程池的种类：

(1)：CachedThreadPool：缓存线程池，该类线程池中线程的数量是不确定的，理论上可以达到Integer.MAX_VALUE个，这种线程池中的线程都是非核心线程，既然是非核心线程，那么就存在超时淘汰机制了，当里面的某个线程空闲时间超过了设定的超时时间的话，就会回收掉该线程；

(2)：FixedThreadPool：固定线程池，这类线程池中是只存在核心线程的，对于核心线程来说，如果我们不设置allowCoreThreadTimeOut属性的话是不存在超时淘汰机制的，这类线程池中的corePoolSize的大小是等于maximumPoolSize大小的，也就是说，如果线程池中的线程都处于活动状态的话，如果有新任务到来，他是不会开辟新的工作线程来处理这些任务的，只能将这些任务放到阻塞队列里面进行等到，直到有核心线程空闲为止；


(3)：ScheledThreadPool：任务线程池，这种线程池中核心线程的数量是固定的，而对于非核心线程的数量是不限制的，同时对于非核心线程是存在超时淘汰机制的，主要适用于执行定时任务或者周期性任务的场景；

(4)：SingleThreadPool：单一线程池，线程池里面只有一个线程，同时也不存在非核心线程，感觉像是FixedThreadPool的特殊版本，他主要用于确保任务在同一线程中的顺序执行，有点类似于进行同步吧；


接下来我们来看第三个问题，创建线程池需要哪些参数：

同样查看ThreadPoolExecutor源码，查看创建线程池的构造函数：

[java]view plain

• publicThreadPoolExecutor(intcorePoolSize,

• intmaximumPoolSize,

• longkeepAliveTime,

• TimeUnitunit,

• BlockingQueue<Runnable>workQueue,

• ThreadFactorythreadFactory,

• )

不管你调用的是ThreadPoolExecutor的哪个构造函数，最终都会执行到这个构造函数的，这个构造函数有7个参数，正是由于对这7个参数值的赋值不同，造成生成不同类型的线程池，比如我们常见的CachedThreadPoolExecutor、FixedThreadPoolExecutor

SingleThreadPoolExecutor、ScheledThreadPoolExecutor，我们老看看这几个参数的具体含义：

<1>corePoolSize：线程池中核心线程的数量；当提交一个任务到线程池的时候，线程池会创建一个线程来执行执行任务，即使有其他空闲的线程存在，直到线程数达到corePoolSize时不再创建，这时候会把提交的新任务放入到阻塞队列中，如果调用了线程池的preStartAllCoreThreads方法，则会在创建线程池的时候初始化出来核心线程；

<2>maximumPoolSize：线程池允许创建的最大线程数；如果阻塞队列已经满了，同时已经创建的线程数小于最大线程数的话，那么会创建新的线程来处理阻塞队列中的任务；

<3>keepAliveTime：线程活动保持时间，指的是工作线程空闲之后继续存活的时间，默认情况下，这个参数只有线程数大于corePoolSize的时候才会起作用，即当线程池中的线程数目大于corePoolSize的时候，如果某一个线程的空闲时间达到keepAliveTime，那么这个线程是会被终止的，直到线程池中的线程数目不大于corePoolSize；如果调用allowCoreThreadTimeOut的话，在线程池中线程数量不大于corePoolSize的时候，keepAliveTime参数也可以起作用的，知道线程数目为0为止；

<4>unit：参数keepAliveTime的时间单位；

<5>workQueue：阻塞队列；用于存储等待执行的任务，有四种阻塞队列类型，ArrayBlockingQueue(基于数组的有界阻塞队列)、LinkedBlockingQueue(基于链表结构的阻塞队列)、SynchronousQueue(不存储元素的阻塞队列)、PriorityBlockingQueue(具有优先级的阻塞队列)；

<6>threadFactory：用于创建线程的线程工厂；

<7>handler：当阻塞队列满了，且没有空闲线程的情况下，也就是说这个时候，线程池中的线程数目已经达到了最大线程数量，处于饱和状态，那么必须采取一种策略来处理新提交的任务，我们可以自己定义处理策略，也可以使用系统已经提供给我们的策略，先来看看系统为我们提供的4种策略，AbortPolicy(直接抛出异常)、CallerRunsPolicy(只有调用者所在的线程来运行任务)、DiscardOldestPolicy(丢弃阻塞队列中最近的一个任务，并执行当前任务)、Discard(直接丢弃)；

接下来就是将任务添加到线程池之后的运行流程了；

我们可以调用submit或者execute方法，两者最大的区别在于，调用submit方法的话，我们可以传入一个实现Callable接口的对象，进而能在当前任务执行结束之后通过Future对象获得任务的返回值，submit内部实际上还是执行的execute方法；而调用execute方法的话，是不能获得任务执行结束之后的返回值的；此外，调用submit方法的话是可以抛出异常的，但是调用execute方法的话，异常在其内部得到了消化，也就是说异常在其内部得到了处理，不会向外传递的；

因为submit方法最终也是会执行execute方法的，因此我们只需要了解execute方法就可以了：

在execute方法内部会分三种情况来进行处理：

<1>：首先判断当前线程池中的线程数量是否小于corePoolSize，如果小于的话，则直接通过addWorker方法创建一个新的Worker对象来执行我们当前的任务；

<2>：如果说当前线程池中的线程数量大于corePoolSize的话，那么会尝试将当前任务添加到阻塞队列中，然后第二次检查线程池的状态，如果线程池不在Running状态的话，会将刚刚添加到阻塞队列中的任务移出，同时拒绝当前任务请求；如果第二次检查发现当前线程池处于Running状态的话，那么会查看当前线程池中的工作线程数量是否为0，如果为0的话，就会通过addWorker方法创建一个Worker对象出来处理阻塞队列中的任务；

<3>：如果原先线程池就不处于Running状态或者我们刚刚将当前任务添加到阻塞队列的时候出现错误的话，那么会去尝试通过addWorker创建新的Worker来处理当前任务，如果添加失败的话，则拒绝当前任务请求；

可以看到在上面的execute方法中，我们仅仅只是检查了当前线程池中的线程数量有没有超过corePoolSize的情况，那么当前线程池中的线程数量有没有超过maximumPoolSize是在哪里检测的呢？实际上是在addWorker方法里面了，我们可以看下addWorker里面的一段代码：

[java]view plain

• if(wc>=CAPACITY||

• wc>=(core?corePoolSize:maximumPoolSize))

• returnfalse;

如果当前线程数量超过maximumPoolSize的话，直接就会调用return方法，返回false；

其实到这里我们很明显可以知道，一个线程池中线程的数量实际上就是这个线程池中Worker的数量，如果Worker的大小超过了corePoolSize，那么任务都在阻塞队列里面了，Worker是Java对我们任务的一个封装类，他的声明是酱紫的：

[java]view plain

• privatefinalclassWorker

• implementsRunnable

可以看到他实现了Runnable接口，他是在addWorker方法里面通过new Worker(firstTask)创建的，我们来看看他的构造函数就知道了：

[java]view plain

• Worker(RunnablefirstTask){

• setState(-1);//

• this.firstTask=firstTask;

• this.thread=getThreadFactory().newThread(this);

• }

而这里的firstTask其实就是我们调用execute或者submit的时候传入的那个参数罢了，一般来说这些参数是实现Callable或者Runnable接口的；

在通过addWorker方法创建出来Worker对象之后，这个方法的最后会执行Worker内部thread属性的start方法，而这个thread属性实际上就是封装了Worker的Thread，执行他的start方法实际上执行的是Worker的run方法，因为Worker是实现了Runnable接口的，在run方法里面就会执行runWorker方法，而runWorker方法里面首先会判断当前我们传入的任务是否为空，不为空的话直接就会执行我们通过execute或者submit方法提交的任务啦，注意一点就是我们虽然会通过submit方法提交实现了Callable接口的对象，但是在调用submit方法的时候，其实是会将Callable对象封装成实现了Runnable接口对象的，不信我们看看submit方法源码是怎么实现的：

[java]view plain

• public<T>Future<T>submit(Callable<T>task){

• if(task==null)thrownewNullPointerException();

• RunnableFuture<T>ftask=newTaskFor(task);

• execute(ftask);

• returnftask;

• }

看到没有呢，实际上在你传入实现了Callable接口对象的时候，在submit方法里面是会将其封装成RunnableFuture对象的，而RunnableFuture接口是继承了Runnable接口的；那么说白了其实就是直接执行我们提交任务的run方法了；如果为空的话，则会通过getTask方法从阻塞队列里面拿出一个任务去执行；在任务执行结束之后继续从阻塞队列里面拿任务，直到getTask的返回值为空则退出runWorker内部循环，那么什么情况下getTask返回为空呢？查看getTask方法的源码注释可以知道：在Worker必须需要退出的情况下getTask会返回空，具体什么情况下Worker会退出呢？(1)：当Worker的数量超过maximumPoolSize的时候；(2)：当线程池状态为Stop的时候；(3)：当线程池状态为Shutdown并且阻塞队列为空的时候；(4)：使用等待超时时间从阻塞队列中拿数据，但是超时之后仍然没有拿到数据；

如果runWorker方法退出了它里面的循环，那么就说明当前阻塞队列里面是没有任务可以执行的了，你可以看到在runWorker方法内部的finally语句块中执行了processWorkerExit方法，用来对Worker对象进行回收操作，这个方法会传入一个参数表示需要删除的Worker对象；在进行Worker回收的时候会调用tryTerminate方法来尝试关闭线程池，在tryTerminate方法里面会检查是否有Worker在工作，检查线程池的状态，没问题的话就会将当前线程池的状态过渡到Tidying，之后调用terminated方法，将线程池状态更新到Terminated；

从上面的分析中，我们可以看出线程池运行的4个阶段：

(1)：poolSize < corePoolSize，则直接创建新的线程(核心线程)来执行当前提交的任务；

(2)：poolSize = corePoolSize，并且此时阻塞队列没有满，那么会将当前任务添加到阻塞队列中，如果此时存在工作线程(非核心线程)的话，那么会由工作线程来处理该阻塞队列中的任务，如果此时工作线程数量为0的话，那么会创建一个工作线程(非核心线程)出来；

(3)：poolSize = corePoolSize，并且此时阻塞队列已经满了，那么会直接创建新的工作线程(非核心线程)来处理阻塞队列中的任务；

(4)：poolSize = maximumPoolSize，并且此时阻塞队列也满了的话，那么会触发拒绝机制，具体决绝策略采用的是什么就要看我们创建ThreadPoolExecutor的时候传入的RejectExecutionHandler参数了；


接下来就是线程池是怎么做到重用线程的呢？

个人认为线程池里面重用线程的工作是在getTask里面实现的，在getTask里面是存在两个for死循环嵌套的，他会不断的从阻塞对列里面取出需要执行的任务，返回给我们的runWorker方法里面，而在runWorker方法里面只要getTask返回的任务不是空就会执行该任务的run方法来处理它，这样一直执行下去，直到getTask返回空为止，此时的情况就是阻塞队列里面没有任务了，这样一个线程处理完一个任务之后接着再处理阻塞队列中的另一个任务，当然在线程池中的不同线程是可以并发处理阻塞队列中的任务的，最后在阻塞队列内部不存在任务的时候会去判断是否需要回收Worker对象，其实Worker对象的个数就是线程池中线程的个数，至于什么情况才需要回收，上面已经说了，就是四种情况了；

最后就是线程池是怎样被关闭的呢？

涉及到线程池的关闭，需要用到两个方法，shutdown和shutdownNow，他们都是位于ThreadPoolExecutor里面的，对于shutdown的话，他会将线程池状态切换成Shutdown，此时是不会影响对阻塞队列中任务执行的，但是会拒绝执行新加进来的任务，同时会回收闲置的Worker；而shutdownNow方法会将线程池状态切换成Stop，此时既不会再去处理阻塞队列里面的任务，也不会去处理新加进来的任务，同时会回收所有Worker；

Ⅵ java for循环中创建线程池

1. 首先要明确线程池的意思，就是线程预先创建好放在一个池里面，使用后不会销毁
   

2. 要区分任务和线程池，任务可以不断添加，但是线程池里线程的个数是固定的，当任务数超过线程数后，后面的任务需要等待有空闲的线程才会执行

3. 所以不断添加任务没有关系，如果池中有50个线程，你添加100个任务同一时间也只会执行50个任务，剩下的50个任务需要等待前面的任务执行完毕后继续执行

4. 所以你的主线程原则上可以不断for，但是你总得有个结束点吧

Ⅶ 如何创建Java中的线程池

ThreadPoolExecutor executor = new ThreadPoolExecutor(2,3,60,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(5));

Ⅷ 创建线程有几种方式和Java中常用的线程池

java创建线程的方式有三种
第一种是继承Thread类 实现方法run() 不可以抛异常 无返回值
第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返回值
第三种是实现Callable<T>接口,接口中要覆盖的方法是 public <T> call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值

第三种如何运行呢 Callable接口在util.concurrent包中,由线程池提交
import java.util.concurrent.*;
ExecutorService e = Executors.newFixedThreadPool(10); 参数表示最多可以运行几个线程
e.submit(); 这个里面参数传 实现Callable接口那个类的对象

Ⅸ 如何创建并运行Java线程

Java线程类也是一个object类,它的实例都继承自java.lang.Thread或其子类。 可以用如下方式用java中创建一个线程：

Tread thread = new Thread();

执行该线程可以调用该线程的start()方法:

thread.start();

在上面的例子中，我们并没有为线程编写运行代码，因此调用该方法后线程就终止了。

编写线程运行时执行的代码有两种方式：一种是创建Thread子类的一个实例并重写run方法，第二种是创建类的时候实现Runnable接口。接下来我们会具体讲解这两种方法：

创建Thread的子类

创建Thread子类的一个实例并重写run方法，run方法会在调用start()方法之后被执行。例子如下：

public class MyThread extends Thread {
public void run(){
System.out.println("MyThread running");
}
}

可以用如下方式创建并运行上述Thread子类

MyThread myThread = new MyThread();
myTread.start();

一旦线程启动后start方法就会立即返回，而不会等待到run方法执行完毕才返回。就好像run方法是在另外一个cpu上执行一样。当run方法执行后，将会打印出字符串MyThread running。

你也可以如下创建一个Thread的匿名子类：

Thread thread = new Thread(){
public void run(){
System.out.println("Thread Running");
}
};
thread.start();

当新的线程的run方法执行以后，计算机将会打印出字符串”Thread Running”。

实现Runnable接口

第二种编写线程执行代码的方式是新建一个实现了java.lang.Runnable接口的类的实例，实例中的方法可以被线程调用。下面给出例子：

public class MyRunnable implements Runnable {
public void run(){
System.out.println("MyRunnable running");
}
}

为了使线程能够执行run()方法，需要在Thread类的构造函数中传入 MyRunnable的实例对象。示例如下：

Thread thread = new Thread(new MyRunnable());
thread.start();

当线程运行时，它将会调用实现了Runnable接口的run方法。上例中将会打印出”MyRunnable running”。

同样，也可以创建一个实现了Runnable接口的匿名类，如下所示：

Runnable myRunnable = new Runnable(){
public void run(){
System.out.println("Runnable running");
}
}
Thread thread = new Thread(myRunnable);
thread.start();

创建子类还是实现Runnable接口？

对于这两种方式哪种好并没有一个确定的答案，它们都能满足要求。就我个人意见，我更倾向于实现Runnable接口这种方法。因为线程池可以有效的管理实现了Runnable接口的线程，如果线程池满了，新的线程就会排队等候执行，直到线程池空闲出来为止。而如果线程是通过实现Thread子类实现的，这将会复杂一些。

有时我们要同时融合实现Runnable接口和Thread子类两种方式。例如，实现了Thread子类的实例可以执行多个实现了Runnable接口的线程。一个典型的应用就是线程池。

常见错误：调用run()方法而非start()方法

创建并运行一个线程所犯的常见错误是调用线程的run()方法而非start()方法，如下所示：

Thread newThread = new Thread(MyRunnable());
newThread.run(); //should be start();

起初你并不会感觉到有什么不妥，因为run()方法的确如你所愿的被调用了。但是，事实上,run()方法并非是由刚创建的新线程所执行的，而是被创建新线程的当前线程所执行了。也就是被执行上面两行代码的线程所执行的。想要让创建的新线程执行run()方法，必须调用新线程的start方法。

线程名

当创建一个线程的时候，可以给线程起一个名字。它有助于我们区分不同的线程。例如：如果有多个线程写入System.out，我们就能够通过线程名容易的找出是哪个线程正在输出。例子如下：

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, "New Thread");
thread.start();
System.out.println(thread.getName());

需要注意的是，因为MyRunnable并非Thread的子类，所以MyRunnable类并没有getName()方法。可以通过以下方式得到当前线程的引用：

Thread.currentThread();

因此，通过如下代码可以得到当前线程的名字：

String threadName = Thread.currentThread().getName();

线程代码举例：

这里是一个小小的例子。首先输出执行main()方法线程名字。这个线程JVM分配的。然后开启10个线程，命名为1~10。每个线程输出自己的名字后就退出。

public class ThreadExample {
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
for(int i=0; i<10; i++){
new Thread("" + i){
public void run(){
System.out.println("Thread: " + getName() + "running");
}
}.start();
}
}
}

需要注意的是，尽管启动线程的顺序是有序的，但是执行的顺序并非是有序的。也就是说，1号线程并不一定是第一个将自己名字输出到控制台的线程。这是因为线程是并行执行而非顺序的。Jvm和操作系统一起决定了线程的执行顺序，他和线程的启动顺序并非一定是一致的。

Ⅹ 【Java基础】线程池的原理是什么

什么是线程池？

总归为：池化技术 ---》数据库连接池 缓存架构 缓存池 线程池 内存池，连接池，这种思想演变成缓存架构技术---> JDK设计思想有千丝万缕的联系

首先我们从最核心的ThreadPoolExecutor类中的方法讲起，然后再讲述它的实现原理，接着给出了它的使用示例，最后讨论了一下如何合理配置线程池的大小。

Java 中的 ThreadPoolExecutor 类

java.uitl.concurrent.ThreadPoolExecutor 类是线程池中最核心的一个类，因此如果要透彻地了解Java 中的线程池，必须先了解这个类。下面我们来看一下 ThreadPoolExecutor 类的具体实现源码。

在 ThreadPoolExecutor 类中提供了四个构造方法：