1 线程概念
2 线程任务
3 线程操作
4 Executor
5 CompletionService
运行程序，会使用到CPU、内存等资源。程序将通过“进程”来申请并管理所需要的相关资源。每个“进程”会有一个“主线程”，“线程”使用进程申请来的资源，去执行相关的逻辑操作。“主线程”可以创建其它新的“线程”，多个“线程”可以并行（同时）执行各自的逻辑操作。
实际上，对于单核处理器而言，多个线程并不是真正的同时执行，而是轮流获得CPU使用权，执行一部分操作，如图：
当每次CPU轮换的时间间隔无限缩小，趋近于0时，给我们的感觉，像是每个线程在同时进行，如图：
对于多核处理器，当线程数量小于处理器核数的时候，每个线程将由其中一个核单独处理。当线程数量大于处理器核数时，某些线程将共享一个核，相当于上述多线程单核情况。
使用线程，首先要确定线程内执行什么任务。有两种方法，来确定线程任务。
2.1 方法一：继承Thread
class ThreadExample extends Thread { // 重写run方法 public void run() { // 线程执行内容 } }
2.2 方法二：实现Runnable
class RunnableExample implements Runnable { // 重写run方法 public void run() { // 线程执行内容 } }
2.3 二者区别
Thread类是对线程的一个抽象，其中包含一些线程的操作方法，例如：启动线程、终止线程等。
Runnable类是对线程任务的一个抽象，主要是包含相关的处理逻辑。
将“线程的操作”与“线程的任务”分离，各自关注各自的职责和任务，是一个很好的方案。
另外，由于Java不允许多继承关系，所以，对于某父类的子类，只能通过实现Runnable接口的方法。
3.1 创建线程对象（构造方法）
若通过继承Thread类（方法一）来定义线程执行内容，则直接创建该子类对象即可。
class ThreadExample extends Thread { // 重写run方法 public void run() { // 线程执行内容 } } class ThreadModel { public static void main(string[] args) { // 创建ThreadExample线程对象 ThreadExample thread = new ThreadExample(); } }
若通过实现Runnable接口（方法二）来定义线程执行内容，则创建标准线程对象并传入Runnable对象。
class RunnableExample implements Runnable { // 重写run方法 public void run() { // 线程执行内容 } } class ThreadModel { public static void main(string[] args) { // 创建RunnableExample对象 RunnableExample runnable = new RunnableExample(); // 创建标准线程并传入runnable对象（传入线程内容） Thread thread = new Thread(runnable); } }
方法二，通过传入Runnable对象来指定线程内容，因此，可以通过Runnable对象实现数据共享（共享的私有变量）。
示例代码如下，多个线程可以使用同一个Runnable对象，当两个线程执行完毕时，私有变量shareNum值为2。
class RunnableExample implements Runnable { // 私有变量 int sharedNum = 1; // 重写run方法 public void run() { sharedNum++; } } class ThreadModel { public static void main(string[] args) { // 创建RunnableExample对象 RunnableExample runnable = new RunnableExample(); // 创建标准线程1并传入runnable对象 Thread thread1 = new Thread(runnable); // 创建标准线程2并传入runnable对象 Thread thread2 = new Thread(runnable); } }
指定与获取线程名称。
// 指定线程名称 Thread thread = new Thread(String threadName); Thread thread = new Thread(Runnable runObj, String threadName); // 获取线程名称 Thread.currentThread().getName();
3.2 启动线程
threadModel.start()
开启一个新的线程。
threadModel.start() 和 threadModel.run() 的区别：
threadModel.start() 是开启一个新线程去执行 run() 方法，如图：
threadModel.run() 是在当前线程中调用 run() 方法，与调用其它方法一样，如图：
3.3 线程睡眠（暂停）
Thread.sleep(long millis)
静态方法。暂停当前线程一段时间（millis-毫秒），继续执行。
当前线程：调用Thread.sleep方法的线程，即Thread.sleep代码所在的线程。
Thread.sleep(long millis) 与 Object.wait() 的区别：
Thread.sleep方法是线程操作方法，Object.wait方法是同步锁的方法。
实际上，二者并不是同一类的内容，不应该进行比较。但是，二者表现出来的效果相似，因此，常常被混淆。
Thread.sleep方法涉及当前线程，是对线程进行暂停操作。
Object.wait涉及同步锁和并发问题，是关于锁和执行权的问题。
具体分析，请浏览《Java内置锁与显式锁浅析》文章。
3.4 终止线程
threadModel.interrupt()
终止threadModel线程，即使该线程还没执行完所有内容。
通过该方法终止线程，会使得被终止的线程抛出InterruptedException异常。
3.5 线程状态
threadModel.isAlive()
判断线程是否存活。若线程存活（没有被销毁），则返回true；否则，返回false。
3.6 线程加入（等待其它线程）
threadOther.join()
当前线程暂停，等待threadOther线程执行完毕后，继续执行，如图：
3.7 降低优先权
Thread.yield()
静态方法。表示临时降低当前线程优先权，使CPU优先分派资源（使用权）给其它线程。
4.1 基本概念
线程池用于管理线程，提供一系列管理线程的方法。
其主要优点在于，通过线程重用，减少线程创建及销毁的次数，从而减少相关操作的消耗。
Executor框架中的线程重用，不是简单的替换Runnable内容并重新运行线程，而是通过线程及阻塞队列达到重用的效果（即不需要重复创建和销毁线程），是典型的“生产者-消费者”模式。线程池会保持所有线程持续运行，每个线程不断从阻塞队列中提取Runnable任务并执行。若队列中无等待执行的任务，则暂时阻塞线程，待新的任务加入队列后，再次唤醒线程，从而达到线程重用的效果。
4.2 创建Executor
ExecutorService executor = Executors.newSingleThreadExecutor()
创建一个单线程池，所有可执行任务将按照指定顺序依次执行，即串行化执行。
ExecutorService executor = Executors.newFixedThreadPool(int threadNum)
创建一个定长线程池，该线程池拥有固定数量的线程，即可控制线程的最大并发数量。当可执行任务的数量超过线程数量时，多余的部分将在队列中等待。
ExecutorService executor = Executors.newCachedThreadPool()
创建一个可缓存的线程池，根据需要增加和减少线程数量，无线程数量限制（但是需要考虑硬件配置）。
ExecutorService executor = new ThreadPoolExecutor(...)
创建一个自定义线程池，可设置核心线程数、最大线程数、闲置线程存活时间、任务队列、任务队列满载处理方法等内容。
4.3 添加执行任务
executor.execute(Runnable task)
将task对象加入执行队列中，当有空闲线程时，按照队列顺序，执行task任务。
Future<V> future = executor.submit(Callable<V> task)
该方法同execute方法，不同之处在于，该方法会返回一个Future对象，通过Future对象，可以获得任务执行结果。
该方法涉及Callable和Future的使用，不在本文讨论范围。
4.4 停止
executor.shutdown()
可理解为关闭添加入口（关闭大门），无法再添加新的执行任务。已经添加到执行队列的任务，不受影响，继续等待被执行。
executor.shutdownNow()
尝试停止所有正在执行和等待执行的任务，并返回所有等待执行的任务列表（List）。
4.5 等待执行结束
executor.awaitTermination(long timeout, TimeUnit unit)
阻塞当前线程（调用该方法的线程），直到线程池中的所有执行任务被完成或发生超时（Timeout）。
5.1 基本概念
通过Executor管理线程池，大大简化了线程操作，通过Future对象，我们还可以对执行中的线程进行控制。
但是，通过Future和Executor框架，我们无法知道哪一个线程会最先执行完毕，因此，无法知道应该先对哪一个Future对象结果进行处理。若通过轮询每一个Future对象并执行get操作，虽然可行，但不是一个好的方法。
CompletionService将Executor和BlockingQueue的功能进行融合，可以将Callable任务交给它进行管理，由CompletionService进行任务的提交。当任务执行完成后，会将结果加入到BlockingQueue队列。因此，我们只需要关注队列中的数据，并通过队列来获取执行结果即可。最先执行完毕的任务会被第一个加入到队列，也将被第一个获取并处理。
5.2 创建CompletionService
CompletionService<T> service = new ExecutorCompletionService<>(Executor executor, BlockingQueue queue)
指定一个Executor和一个阻塞队列，创建一个CompletionService对象，此后，通过service对象进行任务提交和结果获取操作。
5.3 提交任务
service.submit(Callable<T> task)
向service对象提交一个任务，该任务将由executor执行，其结果将加入到queue队列。
5.4 获取结果
Future<T> future = service.poll()
获取下一个已完成任务的Future对象，若暂时没有已完成任务，则返回null值。
Future<T> future = service.take()
获取下一个已完成任务的Future对象，若暂时没有已完成任务，则阻塞等待，直到下一个已完成任务的Future对象被添加至队列。
《Java内置锁与显式锁浅析》
