多线程学习笔记-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