Java-线程知识总结

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:
         * 

         *   
{@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}
         * 
		 //限期等待状态，限期的原因是加入了时间的关系
         */
        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等操作。只要知道即可，后续会再深入分析这些方法。

参考文章：

线程状态图

线程状态图