1. 基本解释：
进程：进程是系统进行资源分配和调度的一个基本单位。
线程：是CPU调度和分派的基本单位。
联系：
线程之间会互相影响，同一个进程中的多个线程之间可以并发执行。
进程的概念更大，线程的概念更接近执行体的概念，它可以与同进程中的的其他线程共享数据，但拥有自己的独立的空间。
区别：
1.1一个程序至少一个进程，一个进程至少一个线程。
1.2进程在执行过程中拥有独立的内存单元，而多个线程共享内存。
1.3从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
2. 线程的状态：
基于Java的Thread的类的分析，它提供了一个State状态的枚举，用于描述线程的状态。
public enum State {
/**
* Thread state for a thread which has not yet started.
//new 出一个Thread对象
*/
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.
//在Thread类里的RUNNABLE是平时我们理解的可运行和运行状态的总称。
//或者更极端一点，当等待某些结果时，线程也是出于这个状态
*/
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:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* 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:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
//限期等待状态，限期的原因是加入了时间的关系
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
//结束状态
*/
TERMINATED;
}以上是源码中对于线程状态的解释，但是呢，通常人们都不会照原样去理解，一般会带上自己的理解和一些额外的状态去进行线程间状态的描述，比如下图（图是自己画的，但是借鉴于网图）：
1.新建：
2.可运行：线程对象创建完成之后，其他线程调用了该对象的start()方法。该线程位于可运行线程池中，等待被调度选中，获取cpu的使用权。
3.运行：获得了cpu的使用权，执行程序代码。
4.阻塞：阻塞状态因为某种原因放弃了cpu的使用权，暂时停止。直到再次获取到可运行状态。注意不是直接切换到运行状态，而是可运行状态，需要cpu再次调度。阻塞分3种：
（一）、等待阻塞，运行的线程执行o.wait()方法，进入被JVM放入等待队列中，但是并不会释放锁。
（二）、同步阻塞，运行的线程在获取synchronize时，该锁被其他占用，则会被JVM放入锁池。
（三）、其他阻塞，运行的线程执行sleep(),join()方法或者发出了I/O请求，JVM会将线程置成阻塞状态。当处理完毕时，重新转入可运行状态。
5.死亡：
以上都是借用的一些辅助状态来描述线程之间状态的切换。我们需要看下原本在Thread类中，Java给我们提供的一些状态，以及在这个基础上的状态切换。
再次具体不分析LockSupport和interrupt等操作。只要知道即可，后续会再深入分析这些方法。
参考文章：