线程定义
线程，有时被称为轻量级进程(lightweight process，lwp），是程序执行流的最小单元。一个标准的线程由线程id，当前指令指针(pc），寄存器集合和堆栈组成。如果没有明确的协同机制，线程将彼此独立执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。
线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源（共享进程的内存地址空间），因此这些线程都能访问相同的变量并在同一个堆上分配对象，这就需要实现一种比在进程间共享数据粒度更细的数据共享机制。如果没有这种同步机制，在多线程的情况下会出现无法预料的后果。
一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。
线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。
java中的线程
一个Java程序的入口是main方法，通过调用main方法开始执行，然后按照代码逻辑执行，看似没有其他线程参与，其实java程序天生就是多线程程序，执行一个main方法其实就是一个名为mian的线程和其他线程分别执行，参考代码如下：
立即学习“Java免费学习笔记（深入）”；
代码（参考java并发编程艺术）
package com.sunld;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo; import java.lang.management.ThreadMXBean;/** * @Title: TestMainThread.java * @Package com.sunld *Description:
* @author sunld * @version V1.0.0 *
易达中小企业CMS管理系统1.8.6下载初次使用易达CMS企业系统以下简称(易达)，易达系统运行于微软公司开发的 ASP 程序平台，ASP是目前国内应用最广泛的WEB开发语言,空间基于微软windows IIS,使您的购买空间和维护成本降到最低，并以其众多独创或领先的新特性和功能设计，使得用户深刻体验到易达以原创研发、服务客户为主导开发理念的独到之处和领先优势，易达严格上讲是为懂点网站建设和HTML或DIV+CSS技术的人员而开发的一套
CreateDate:2017年9月28日 下午3:54:19
*/public class TestMainThread { public static void main(String[] args) { // 获取Java线程管理MXBean ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); // 不需要获取同步的monitor和synchronizer信息，仅获取线程和线程堆栈信息 ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false); // 遍历线程信息，仅打印线程ID和线程名称信息 for (ThreadInfo threadInfo : threadInfos) { System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName()); } } }
返回结果
[5] Attach Listener//附加监听 [4] Signal Dispatcher//分发处理发送给JVM信号的线程 [3] Finalizer//调用对象finalize方法的线程 [2] Reference Handler清除Reference的线程 [1] mainmain线程，用户程序入口
线程状态
源码定义
/**
* A thread state. A thread can be in one of the following states:
* -
*
- {@link #NEW}
* A thread that has not yet started is in this state. *
* - {@link #RUNNABLE}
* A thread executing in the Java virtual machine is in this state. *
* - {@link #BLOCKED}
* A thread that is blocked waiting for a monitor lock * is in this state. *
* - {@link #WAITING}
* A thread that is waiting indefinitely for another thread to * perform a particular action is in this state. *
* - {@link #TIMED_WAITING}
* A thread that is waiting for another thread to perform an action * for up to a specified waiting time is in this state. *
* - {@link #TERMINATED}
* A thread that has exited is in this state. *
*
* A thread can be in only one state at a given point in time. * These states are virtual machine states which do not reflect * any operating system thread states. * * @since 1.5 * @see #getState */ public enum State { /** * Thread state for a thread which has not yet started. */ NEW, /** * Thread state for a runnable thread. A thread in the runnable * state is executing in the Java virtual machine but it may * be waiting for other resources from the operating system * such as processor. */ RUNNABLE, /** * Thread state for a thread blocked waiting for a monitor lock. * A thread in the blocked state is waiting for a monitor lock * to enter a synchronized block/method or * reenter a synchronized block/method after calling * {@link Object#wait() Object.wait}. */ BLOCKED, /** * Thread state for a waiting thread. * A thread is in the waiting state due to calling one of the * following methods: *
-
*
- {@link Object#wait() Object.wait} with no timeout *
- {@link #join() Thread.join} with no timeout *
- {@link LockSupport#park() LockSupport.park} *
A thread in the waiting state is waiting for another thread to * perform a particular action. * * For example, a thread that has called Object.wait() * on an object is waiting for another thread to call * Object.notify() or Object.notifyAll() on * that object. A thread that has called Thread.join() * is waiting for a specified thread to terminate. */ WAITING, /** * Thread state for a waiting thread with a specified waiting time. * A thread is in the timed waiting state due to calling one of * the following methods with a specified positive waiting time: *
-
*
- {@link #sleep Thread.sleep} *
- {@link Object#wait(long) Object.wait} with timeout *
- {@link #join(long) Thread.join} with timeout *
- {@link LockSupport#parkNanos LockSupport.parkNanos} *
- {@link LockSupport#parkUntil LockSupport.parkUntil} *
状态转换图
状态说明
Java多线程的就绪、运行和死亡状态
就绪状态转换为运行状态：当此线程得到处理器资源；
运行状态转换为就绪状态：当此线程主动调用yield()方法或在运行过程中失去处理器资源。
运行状态转换为死亡状态：当此线程线程执行体执行完毕或发生了异常。
此处需要特别注意的是：当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性，因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。
由于实际的业务需要，常常会遇到需要在特定时机终止某一线程的运行，使其进入到死亡状态。目前最通用的做法是设置一boolean型的变量，当条件满足时，使线程执行体快速执行完毕（不在执行run方法）在后续的文章中会介绍如何安全的终止一个线程。。
状态分析–jvisualvm
代码-参考（java并发编程艺术）
package com.sunld; import java.util.concurrent.TimeUnit;/** * @Title: TestThreadState.java * @Package com.sunld *Description:
* @author sunld * @version V1.0.0 *CreateDate:2017年9月28日 下午5:14:27
*/public class TestThreadState { public static void main(String[] args) { new Thread(new TimeWaiting (), "TimeWaitingThread").start(); new Thread(new Waiting(), "WaitingThread").start(); // 使用两个Blocked线程，一个获取锁成功，另一个被阻塞 new Thread(new Blocked(), "BlockedThread-1").start(); new Thread(new Blocked(), "BlockedThread-2").start(); } //该线程不断地进行睡眠 static class TimeWaiting implements Runnable{ @Override public void run() { SleepUtils.second(100); } } //该线程在Waiting.class实例上等待 static class Waiting implements Runnable{ @Override public void run() { while (true) { synchronized (Waiting.class) { try { Waiting.class.wait(); }catch(InterruptedException e) { e.printStackTrace(); } } } } } //该线程在Blocked.class实例上加锁后，不会释放该锁 static class Blocked implements Runnable { @Override public void run() { synchronized (Blocked.class) { while (true) { SleepUtils.second(100); } } } } }class SleepUtils{ public static final void second(long seconds) { try { TimeUnit.SECONDS.sleep(seconds); }catch(InterruptedException e) { e.printStackTrace(); } } }
dump结果
2017-09-28 17:26:47Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.112-b15 mixed mode): //BlockedThread-2线程获取到了Blocked.class的锁"BlockedThread-2" #13 prio=5 os_prio=0 tid=0x000000001f268000 nid=0x3754 waiting on condition [0x000000002009f000] java.lang.Thread.State: TIMED_WAITING (sleeping) //BlockedThread-1线程阻塞在获取Blocked.class示例的锁上"BlockedThread-1" #12 prio=5 os_prio=0 tid=0x000000001f266800 nid=0x89c waiting for monitor entry [0x000000001ff9f000] java.lang.Thread.State: BLOCKED (on object monitor) //WaitingThread线程在Waiting实例上等待"WaitingThread" #11 prio=5 os_prio=0 tid=0x000000001f260800 nid=0x4d08 in Object.wait() [0x000000001fe9f000] java.lang.Thread.State: WAITING (on object monitor) //TimeWaitingThread线程处于超时等待"TimeWaitingThread" #10 prio=5 os_prio=0 tid=0x000000001f25f000 nid=0x42ac waiting on condition [0x000000001fd9e000] java.lang.Thread.State: TIMED_WAITING (sleeping)
