多线程学习笔记-1-进程和线程以及状态

• 进程：是系统进行分配和管理资源的基本单位
• 线程：进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。
• 一个程序至少一个进程，一个进程至少一个线程。
• 进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。如何处理好同步与互斥是编写多线程程序的难点。多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以可能一个线程出现问题，进而导致整个程序出现问题

• 首先我们查看源码Thread，1742行，内部枚举类，State

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

• 线程状态

  • 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

  • 运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。

  • 阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。

  • 等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

  • 超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。

  • 终止(TERMINATED)：表示该线程已经执行完毕。

• 我们可以通过代码去实现查看，用java自带的工具jconsole，打开cmd直接输入jconsole即可

  • 初始(NEW)：

    • 这个我想大家应该没什么疑问。就是以下代码，还没有调用start();

      Thread thread = new Thread();

  • 运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器

    • 调用start();就是运行状态了。需要注意的是CPU分配给线程相应的时间，所以start()，也不一定已经执行了run方法

      public static void main(String[] args) {
              Thread thread = new Thread(() ->{
                  try {
                      System.in.read(); //不让程序立马退出，打开jconsole
                  }catch (IOException e){
                      e.printStackTrace();
                  }
              });
              thread.start();
          }

    • 

  • 阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。

    public static void main(String[] args) throws Exception{
            Object obj = new Object();
            Thread thread1 = new Thread(() -> {
                synchronized(obj){
                    try {
                        System.out.println("thread1:拿到锁了");
                        //为了让该线程一直拿到锁
                        Thread.sleep(1000000000L);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });
            thread1.start();
            //为了保证thread能拿到锁
            Thread.sleep(3000);
            Thread thread2 = new Thread(() -> {
               synchronized (obj){
                   System.out.println("thread2:拿到锁了");
               }
            });
            thread2.start();
        }

  • 打开jconsole查看线程第二个
    • 
  • 超时等待(TIME_WAITING)

    • 打开上图的Thread-0

    • ​​​​​​​

一图解千愁

• ​​​​​​​