JUC- 基本概念

1- JUC基本概念

java.util.concurrent 包是在并发编程中使用的工具类，有以下三个包
在这里插入图片描述

2- 进程和线程

2.1 什么是进程

程序是静止的，运行中的程序就是进程，是系统的进行资源分配和调用的独立单位。
每一个进程都有它自己的内存空间和系统资源。

2.2 什么是线程

线程是属于进程的。一个进程可以包含多个线程，这就是多线程。
在同一个进程内可以执行多个任务，而这每一个任务就可以看成是一个线程。
线程是程序的执行单位，执行路径是程序使用cpu的最基本单位。线程也支持并发性。

2.3 简洁概念

进程: 就是操作系统中的运行的一个程序。比如 QQ.exe, chrome.exe …这是多个进程。

线程：每个进程中都存在一个或者多个线程，比如Typora写文档的时候，就会有一个线程默默帮你定时自动保存。

3- 并发和并行

3.1 基本概念

并行：多个人一起跑路。

CPU多核，多个线程同时执行，比如线程池，效率最高。

并发: 多线程操作同一个资源。

CPU一核，模拟出来多条线程，天下武功，为快不破，快速交替。

3.2 并发和并行区别

并发偏重于多个任务交替执行，而多个任务之间有可能还是串行的。并发是逻辑上的同时发生而并行是物理上的同时发生。然而并行的偏重点在于”同时执行”。
并行的多个任务是真实的同时执行，而对于并发来说，这个过程只是交替的，一会运行任务一,一会儿又运行任务二，系统会不停地在两者间切换。

3.2 并发和并行动机制

并发的动机：在计算能力恒定的情况下处理更多的任务, 就像我们的大脑, 计算能力相对恒定, 要在一天中处理更多的问题, 我们就必须具备多任务的能力. 现实工作中有很多事情可能会中断你的当前任务, 处理这种多任务的能力就是你的并发能力。

并行的动机：用更多的CPU核心更快的完成任务. 就像一个团队, 一个脑袋不够用了, 一个团队来一起处理一个任务。所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

3.3 线程的状态

Java的线程有6种状态

public enum State {
    
    
    /**
     * Thread state for a thread which has not yet started.
     */
    
    // 1. 线程创建
    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.
      */
    
    // 2.在jvm中正在运行的线程
    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}.
     */
    
    // 3. 线程处于阻塞状态，等待监视锁，可以重新进行同步代码块中执行
    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.
      */
    
    // 4. 等待状态
    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>
      */
    
    // 5.调用sleep() join() wait()方法可能导致线程处于等待状态
    TIMED_WAITING,

    /**
      * Thread state for a terminated thread.
      * The thread has completed execution.
      */
    
    // 6.线程执行完毕，已经退出
    TERMINATED;
}

图示
在这里插入图片描述

3.3.1 wait和sleep 的区别

来自不同的类

这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。
sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。
是否释放资源

sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
sleep是线程被调用时，占着cpu其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu。也就是说sleep有时间限制的，就像闹钟一样到时候闹钟铃声就响了，而wait是无限期的除非用户主动notify。
使用范围不同

wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。
```
synchronized(x){
      
      
	// x.wait()
	x.notify()
}
```
是否需要捕获异常

sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常。