进程和线程

　　说到多线程，必然绕不开进程与线程的概念及区别。

　　对于计算机而言，当前的操作系统可以同时运行多个应用程序，而每一个应用程序就是一个进程（Process），它拥有自己独立的内存空间。线程是进程中的一个执行流程，是执行任务的最小单位。一个进程内部允许同时启动多个线程（Thread），同时执行多个任务。线程是轻量级的进程，它负责在单个程序里执行多任务，通常由操作系统负责多个线程的调度和执行。 

　　进程与线程的主要区别在于：每个进程都需要操作系统为其分配独立的内存空间，而同一个进程中的所有线程在同一块地址空间中，这些线程可以共享数据。【每个进程都拥有自己的一套变量，而线程可以共享数据】 
 
多线程
 
　　多线程是并发编程的基础。
 
　　多线程的好处在于可以同时并发执行多个任务。当程序的某个功能部分正在等待资源而又不愿意因为等待而造成程序暂停，就可以创建另外的线程进行它的工作。
 
　　多线程可以最大限度地降低CPU的闲置时间，从而提高CPU的利用率。
 
主存与工作内存
 
　　多线程将内存抽象为两类：主内存和工作内存。主内存，简称主存，是所有线程共享的内存，主要存放共享的变量（即：类变量）。工作内存是Java线程的本地内存，是单独给每一个线程分配的特有的工作内存，用来存放局部变量和共享变量的副本。
 
　　既然主内存已经存有共享变量，为何还有在工作内存中存放共享变量的副本呢？原因在于线程与主存之间的通信效率比较低，频繁的通信会降低系统性能。当线程进行读写操作时，只需要对工作内存中的变量进行操作。【关于主存和工作内存请查看并发编程之Java内存模型 】
 
 线程的生命周期
 
　　从JDK的源码（sun.misc.VM#toThreadState）中，我们可以看出，线程的生命周期分为６个状态：NEW（新创建）、RUNNANLE（可运行）、BLOCKED（被阻塞）、WAITING（等待）、TIMED_WAITING（计时等待）、TERMINATED（中终止）．
  1. /**
  2. * A thread state.  A thread can be in one of the following states:
  3. * <ul>
  4. * <li>{@link #NEW}
  5. *     A thread that has not yet started is in this state.
  6. * </li>
  7. * <li>{@link #RUNNABLE}
  8. *     A thread executing in the Java virtual machine is in this state.
  9. *</li>
  10. * <li>{@link #BLOCKED}
  11. *     A thread that is blocked waiting for a monitor lock
  12. *     is in this state.
  13. * </li>
  14. * <li>{@link #WAITING}
  15. *     A thread that is waiting indefinitely for another thread to
  16. *     perform a particular action is in this state.
  17. * </li>
  18. * <li>{@link #TIMED_WAITING}
  19. *     A thread that is waiting for another thread to perform an action
  20. *     for up to a specified waiting time is in this state.
  21. * </li>
  22. * <li>{@link #TERMINATED}
  23. *     A thread that has exited is in this state.
  24. * </li>
  25. * </ul>
  26. *
  27. * <p>
  28. * A thread can be in only one state at a given point in time.
  29. * These states are virtual machine states which do not reflect
  30. * any operating system thread states.
  31. *
  32. * @since   1.5
  33. * @see #getState
  34. */
  35.  
  36. public static State toThreadState(int var0) {
  37.     if ((var0 & 4) != 0) {
  38.         return State.RUNNABLE;
  39.     } else if ((var0 & 1024) != 0) {
  40.         return State.BLOCKED;
  41.     } else if ((var0 & 16) != 0) {
  42.         return State.WAITING;
  43.     } else if ((var0 & 32) != 0) {
  44.         return State.TIMED_WAITING;
  45.     } else if ((var0 & 2) != 0) {
  46.         return State.TERMINATED;
  47.     } else {
  48.         return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
  49.     }
  50. }

 

　　线程状态之间的转换关系如下图：

                

 

  • 刚创建的线程处于NEW状态
  • 调用start（）后，线程处于RUNNANLE状态【线程何时开始执行任务，受CPU的控制。当CPU有空闲资源时，才会运行线程】
  • 在等待获取锁资源的时候，线程会处于BLOCKED状态
  • 线程在等待另一个线程的通知时，会处于WAITING状态
  • 线程在指定时间内等待另一个线程通知，会处于TIMED_WAITING状态
  • 线程运行结束或出现异常，就会变为TERMINATED状态
  • 获取线程的当前状态：getState()
  1. public Thread.State getState() {
  2.     return VM.toThreadState(this.threadStatus);
  3. }

 

　　从源码中可以看出，线程的状态与VM有很大的关系。在JVM中，与线程创建、运行、销毁等关系比较大的是Java虚拟机栈内存。【JVM的基本机构可查看JVM之基本结构 】

 

 

版权声明：本文为BlueStarWei原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/BlueStarWei/p/11492312.html