线程池执行线程调用方法是ThreadPoolExecutor.execute(Runnable command)。
查看execute的源码：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
else if (!addWorker(command, false))
reject(command);
其中有个addWorker()，继续跟进：
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
} finally {
mainLock.unlock();
if (workerAdded) {
t.start();
workerStarted = true;
} finally {
if (! workerStarted)
addWorkerFailed(w);
return workerStarted;
可以看到，传进的参数firstTask作为一个参数构造Worker后，又从Worker对象中找到取了了线程去执行。
我看看下Worker的构造方法：
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
Worker的定义，继承了Runnable，也就是说它本身就是个线程。，说明它是可被线程驱动执行的任务。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
构造方法里，thread变量构造的线程是它本身。
也就是说，最终执行的是Worker类的run方法。
看run方法：
public void run() {
runWorker(this);
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
} finally {
task = null;
w.completedTasks++;
w.unlock();
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
我们看到，其中有一个执行：task = getTask()
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
这个方法就是在从队列里面取线程：workQueue.tack()。这个方法是阻塞的，如果取不到会一直等着，知道直到队列里面放入了新的线程。
线程池执行线程调用方法是ThreadPoolExecutor.execute(Runnable command)。查看execute的源码：public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.ge...
1：必须明白为什么要使用线程池：(这点很重要)
a:手上项目所需，因为项目主要的目的是实现多线程的数据推送；需要创建多线程的话，那就要处理好线程安全的问题；因为项目需要，还涉及到排队下载的功能，所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能；
b:在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题（这段是摘自网络）
2：如何创建一个线程池：
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
说明一下这些参数的作用:
corePoolSize：核心池的大小，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中;
maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；这个参数是跟后面的阻塞队列联系紧密的；只有当阻塞队列满了，如果还有任务添加到线程池的话，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务；如果继续添加任务到线程池，且线程池中的线程数已经达到了maximumPoolSize，那么线程就会就会执行reject操作（这里后面会提及到）
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止；默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用；即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法并设置了参数为true，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的阻塞队列大小为0；（这部分通过查看ThreadPoolExecutor的源码分析--getTask()部分）；
unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性（时间单位）
workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
threadFactory：线程工厂，主要用来创建线程：默认值 DefaultThreadFactory；
handler：表示当拒绝处理任务时的策略，就是上面提及的reject操作；有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。（默认handle）
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
3：对线程池的基本使用及其部分源码的分析（注意：这里的源码分析是基于jdk1.6；）
a:线程池的状态
volatile int runState;
static final int RUNNING = 0; 运行状态
static final int SHUTDOWN = 1; 关闭状态；SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕
static final int STOP = 2;停止状态；此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务
static final int TERMINATED = 3;终止状态；当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态
b:参数再次说明。这是摘自网络的解释，我觉得他比喻的很好，所以这里直接就用它的解释
这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。
corePoolSize在很多地方被翻译成核心池大小，其实我的理解这个就是线程池的大小。举个简单的例子：
假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。
因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做；
当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待；
如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来；
然后就将任务也分配给这4个临时工人做；
如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。
当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。
这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。
也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量突然过大时的一种补救措施。
不过为了方便理解，在本文后面还是将corePoolSize翻译成核心池大小。
largestPoolSize只是一个用来起记录作用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。
c:添加线程池任务的入口就是execute();
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();//任务为空时抛出异常
//如果线程池线程大小小于核心线程，就新建一个线程加入任务并启动线程
//如果线程池线程大小大于核心线且且添加任务到线程失败，就把任务添加到阻塞队列
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {//新建线程并启动
if (runState == RUNNING && workQueue.offer(command)) {//添加任务到队列
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);//添加到队列失败或已满，做拒接任务处理策略
//若阻塞队列失败或已满；这里新建一个线程并启动做应急处理（这里就是用到了maximumPoolSize参数）
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // 若线程池的线程超过了maximumPoolSize；就做拒绝处理任务策略
-->>继续跟踪代码到addIfUnderCorePoolSize(Runnable firstTask)：函数名称就可以看出来这个函数要执行的什么；如果线程池的线程小于核心线程数corePoolSize就新建线程加入任务并启动线程【在今后的开发中尽量把需要做的功能在函数名体现出来】
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;//获取当前线程池的锁
mainLock.lock();//加锁
try {
这里线程池线程大小还需要判断一次；前面的判断过程中并没有加锁，因此可能在execute方法判断的时候poolSize小于corePoolSize，而判断完之后，在其他线程中又向线程池提交了任务，就可能导致poolSize不小于corePoolSize了，所以需要在这个地方继续判断
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);//新建线程
} finally {
mainLock.unlock();
if (t == null)
return false;
t.start();//若创建线程超过，就启动线程池的线程
return true;
private Thread addThread(Runnable firstTask) {
Worker w = new Worker(firstTask);//worker：ThreadPoolExecutor的内部类；
Thread t = threadFactory.newThread(w);//使用线程工厂创建一个线程
if (t != null) {
w.thread = t;
workers.add(w);//保存线程池正在运行的线程
int nt = ++poolSize;//线程池的线程数加1
if (nt > largestPoolSize)
largestPoolSize = nt;
return t;
-->>接下来定位worker类，看看线程池里的线程是如何执行的
上面的addIfUnderCorePoolSize(..)已经把线程启动了；现在就直接查看worker 的run()方法了
public void run() {
try {
Runnable task = firstTask;//该线程的第一个任务，执行完后就从阻塞队列取任务执行
firstTask = null;
while (task != null || (task = getTask()) != null) {//getTask()从队列去任务执行
runTask(task);//线程执行任务
task = null;
} finally {
workerDone(this);//若任务全部执行完，就开始尝试去停止线程池；这部分代码就不再追踪下去，有兴趣的读者可以自己打开源码分析，不必害怕，学习大神们的编码方式，看源码能让你学习到很多
private void runTask(Runnable task) {
final ReentrantLock runLock = this.runLock;
runLock.lock();
try {
//多次检查线程池有没有关闭
if (runState < STOP &&
Thread.interrupted() &&
runState >= STOP)
thread.interrupt();
boolean ran = false;
//这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务之前的统计工作或者用来保存正在执行的任务
beforeExecute(thread, task);
try {
task.run();
ran = true;
//这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务完成之后的统计工作或者用来保存正在执行的任务
afterExecute(task, null);
++completedTasks;//统计总共执行的任务数
} catch (RuntimeException ex) {
if (!ran)
afterExecute(task, ex);
throw ex;
} finally {
runLock.unlock();
至此线程池基本的流程完了；
再说说我在项目中的使用：
MyExtendThreadPoolExecutor 继承了 ThreadPoolExecutor，并覆盖了其中的一些方法
public class MyExtendThreadPoolExecutor extends ThreadPoolExecutor{
public static Logger logger=LoggerFactory.getLogger(MyExtendThreadPoolExecutor.class);
* 记录运行中任务
private LinkedBlockingQueue<Runnable> workBlockingQueue=new LinkedBlockingQueue<Runnable>();
public MyExtendThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
workBlockingQueue.add((GtdataBreakpointResumeDownloadThread)r);//保存在运行的任务
logger.info("Before the task execution");
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
workBlockingQueue.remove((GtdataBreakpointResumeDownloadThread)r);//移除关闭的任务
logger.info("After the task execution");
* Description: 正在运行的任务
* @return LinkedBlockingQueue<Runnable><br>
* @author lishun
public LinkedBlockingQueue<Runnable> getWorkBlockingQueue() {
return workBlockingQueue;
MyExtendThreadPoolExecutor pool = new MyExtendThreadPoolExecutor(3, 3,60L,TimeUnit.SECONDS,new LinkedBlockingQueue <Runnable>()); //创建线程池
public void addToThreadPool(DownloadRecord downloadRecord){
BlockingQueue<Runnable> waitThreadQueue = pool.getQueue();//Returns the task queue
LinkedBlockingQueue<Runnable> workThreadQueue =pool.getWorkBlockingQueue();//Returns the running work
GtdataBreakpointResumeDownloadThread downloadThread =
new GtdataBreakpointResumeDownloadThread(downloadRecord);//需要执行的任务线程
if (!waitThreadQueue.contains(downloadThread)&&!workThreadQueue.contains(downloadThread)) {//判断任务是否存在正在运行的线程或存在阻塞队列，不存在的就加入线程池（这里的比较要重写equals()）
Timestamp recordtime = new Timestamp(System.currentTimeMillis());
logger.info("a_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" add to workThreadQueue");
downloadThread.setName("th_"+downloadRecord.getName());
pool.execute(downloadThread);//添加到线程池
}else{
logger.info("i_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" in waitThreadQueue or workThreadQueue");
多线程编程中，为每个任务分配一个线程是不现实的，线程创建的开销和资源消耗都是很高的。线程池应运而生，成为我们管理线程的利器。Java 通过Executor接口，提供了一种标准的方法将任务的提交过程和执行过程解耦开来，并用Runnable表示任务。
下面，我们来分析一下 Java 线程池框架的实现ThreadPoolExecutor。
下面的分析基于JDK1.7
ThreadPoolExecutor中，使用CAPACITY的高3位来表示运行状态，分别是：
RUNNING：接收新任务，并且处理任务队列中的任务
SHUTDOWN：不接收新任务
线程池的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其他线程执行完毕再从队列中取出任务来执行。
在开发过程中，合理地使用线程池能够带来3个好处：
降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗；
提高响应速度。 当任务到达时，任务可以不需要等到线程创建就能立即执行；
提高线程的可管理性。 线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。
线程池概述
线程池:是一个存储线程的容器,当我们要使用线程的时候,就可以从线程池中获取一个线程,使用完毕在把线程归还到线程池
java.util.concurrent.Executors:是一个创建线程池的工厂类,专门用来生产线程池,里边的方法都是静态的
静态方法:
static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池，以共享的无界队列方式来
可以说，线程池是Java并发场景中应用到的最多并发框架了。几乎所有需要异步或者并发执行的任务程序都可以使用线程池。在开发过程中，合理的使用线程池会带来以下3个好处：
降低资源的消耗。如果了解Java线程的前因后果，对于这一点应该很好理解。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不同等到创建线程立即就能立即执行。
提高线程的可管理性。线程是稀缺资源，通过线程池框架可以进行统一的线程分配、监控、调优。
世界上没有完美无瑕的事情，任何事情都有正反两面。
java线程池之ThreadPoolExecutorwhy如何创建线程池ThreadPoolExecutor怎么使用ThreadPoolExecutor 例子总结
为什么你需要线程池？答案往往是当你开发个简单并发的java程序，或者创建Runnable对象，用Thread来执行。创建一个java线程是个非常昂贵的操作。如果每次创建新的线程实例执行Task， 应用表现是糟糕的。
如何创建线程池
一个线程池是一组预先定义的线程集合。一般来说，池的大小是固定的，但是不是强制的。这方便用相同的线程执行多个任
1.问题引出
我们知道一个线程创建的时候就会附带一个Runnable任务，如果该Runable任务执行完毕后，该线程如何从线程池的等待队列中获取一个任务呢？
上一篇博客讲到线程池中线程和该线程的第一个任务封装在一个Worker类中，这个Worker类本身实现了Runnable接口，源码定义：
private final class Worker extends AbstractQueuedSync...
文章目录前言一、科学的线程数计算二、CPU和Java中的核心和线程三、线程核心数获取四、参考资料
最近有需求可能会使用到线程池，本来是使用本的一个简单的判断逻辑，但是为了自己代码可靠性更高，我重新查询了线程池的科学设置方法。
没耐心可直接去三复制代码
一、科学的线程数计算
最早去了解相关的知识，看到类似以下的公式就头晕，就没有继续深究
之后我的线程池数量判断就是如下
int i = Runtime.getRuntime().availableProcessors();
ExecutorService
【线程池简述】
线程池中，当需要使用线程时，会从线程池中获取一个空闲线程，线程完成工作时，不会直接关闭线程，而是将这个线程退回到池子，方便其它人使用。
简而言之，使用线程池后，原来创建线程变成了从线程池获得空闲线程，关闭线程变成了向池子归还线程。
【线程池带来的好处】
1.降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的性能消耗。
2.提高响应速度，当任务到达时，任务...
public boolean isEndTask() {
while (true) {
if (this.ThreadPoolExecutor.getActiveCount() == 0) {
return true;
if (isEndTask())
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.sc...
通过ThreadPoolExecutor创建线程池的方式有多种。其中一种方式是使用ThreadPoolExecutor的构造函数来手动创建线程池。可以设置线程池的核心线程池大小、最大线程池大小、线程空闲时间、任务队列、线程工厂和拒绝策略等参数。例如，可以使用以下代码创建一个线程池：
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
2, // 核心线程池大小
5, // 最大线程池大小
3, // 线程空闲时间
TimeUnit.SECONDS, // 时间单位
new LinkedBlockingQueue<>(3), // 任务队列
Executors.defaultThreadFactory(), // 线程工厂
new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
在这个例子中，线程池的核心线程池大小为2，最大线程池大小为5，线程空闲时间为3秒，任务队列使用LinkedBlockingQueue，线程工厂使用默认的线程工厂，拒绝策略使用AbortPolicy。然后可以通过execute方法向线程池提交任务。最后，记得在不需要使用线程池时调用shutdown方法关闭线程池。
#### 引用[.reference_title]
- *1* *2* [ThreadPoolExecutor 手动创建线程池](https://blog.csdn.net/Q17532573105/article/details/124698108)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item]
- *3* [通过ThreadPoolExecutor的方式创建线程池](https://blog.csdn.net/m0_45303174/article/details/123587122)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]
