并发编程体系-进程与线程

进程与线程

1. 进程与线程：
   1. 程序：程序由指令和数据组成，这些指令要运行，数据就要读写，就必须将指令加载到CPU，数据加载到内存，在指令运行过程中还需要用到磁盘、网络等设备。
   2. 进程：进程用来加载指令、管理内存、管理IO的。进程是资源分配的最小单位，系统运⾏⼀个程序即是⼀个进程从创建，运⾏到消亡的过程，即进程是程序的一个实例，进程会占用某些系统资源如 CPU 时间，内存空间，⽂件，输⼊输出设备的使⽤权。
   3. 线程：线程是比进程更小的执行单位，是最小的调度单位。一个进程可以产生多个线程，一个线程就是一个指令流，将指令流中的指令按一定顺序交给CPU执行，多个线程可以共享进程中堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈、本地方法栈。

2. 线程和进程的区别
   1. 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
   2. 进程拥有共享的资源，如内存空间等，供其内部的线程共享
   3. 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低
   4. 进程之间的通信比较复杂，不同计算机通信还需遵循网络中的协议

3. 并发和并行
   1. 并发（concurrent）：同一时段线程轮流使用CPU，即同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行（同一时间应对多件事情的能力）
   2. 并行（parallel）：同一时刻，有多条指令在多个处理器上同时执行（同一时间动手做多件事情的能力）

4. 同步和异步
   1. 同步：从方法调用的角度，需要等待结果返回才能继续运行
   2. 异步：从方法调用的角度，不需要等待结果返回才能继续运行

5. 为什么要使用多线程
   1. 线程是程序执⾏的最⼩单位,线程间的切换和调度的成本远远⼩于进程。
   2. 单核时代多线程主要是为了提⾼ CPU 和 IO 设备的综合利⽤率。多核时代多线程能提高CPU的利用率。
   3. 多核 CPU 意味着多个线程可以同时运⾏，这减少了线程上下⽂切换的开销。
   4. 多线程是开发高并发系统的基础。

6. 多线程的利弊
   能提⾼程序的执⾏效率提⾼程序运⾏速度，但是并发编程并不总是能提⾼程序运⾏速度的，⽽且并发编程可能会遇到很多问题，⽐如：内存泄漏、上下⽂切换、死锁还有受限于硬件和软件的资源闲置问题。

7. 创建线程的三种方式
   1. 直接使用Thread
   Thread t= new Thread(){ @override public void run(){ }}; t.start();
   2. 使用Runnable配合Thread
   Runnable runnable = new Runnable() { @Override public void run(){ // 要执行的任务 } }; // 创建线程对象 Thread t = new Thread( runnable ); // 启动线程 t.start();
   3. FutureTask配合Thread（Callable）
   FutureTask<Integer> task3 = new FutureTask<>(new Callable<Integer>(){ log.debug("hello"); return 100; }); // 参数1 是任务对象; 参数2 是线程名字，推荐 new Thread(task3, "t3").start(); // 主线程阻塞，同步等待 task 执行完毕的结果 Integer result = task3.get(); log.debug("结果是:{}", result);
   4. Thread和Runnable的关系

   		1.  Thread是把线程和任务合并在了一起，Runnable 是把线程和任务分开了
   		2. 用 Runnable 更容易与线程池等高级 API 配合，让任务类脱离了 Thread 继承体系，更灵活
   

8. 查看进程线程的方法

   1. Windows下：tasklist 查看进程 taskkill 杀死进程
   2. Linux下：
   3. Java：

9. 线程上下文切换（Thread Context Switch）

   1. 什么情况会发生上下文切换？
   		 线程的CPU时间片用完、垃圾回收、有更高优先级的线程需要运行、线程自己调用了sleep、wait、yield等方法
   2. **上下文切换**：当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对通过程序计数器来实现功能，它的作用是记住下一条 jvm 指令的执行地址，是线程私有的。即**任务从保存到再加载的过程就是⼀次上下⽂切换。**
   3. **频繁切换上下文会影响性能**
   

10. 常用的方法

       1. start() --启动一个新的线程并运行run()方法中的代码，让线程进入**就绪状态**，只能调用一次
       2. **join()方法**--等待当前线程运行结束。处于waiting状态。
       3. **join(long n)**--等待当前线程运行结束,最多等待 n 毫秒。处于**Timed_Waiting**状态
       4. **wait()**--让当前线程进入等待状态，同时，wait()也**会让当前线程释放它所持有的锁**。
       5. wait(long timeout)--让当前线程进入等待状态，最多等待 n 毫秒。处于**Timed_Waiting**状态
       6. **sleep(long n)**--程序休眠执行指定的时间，让出cpu该其他线程，**这个过程不会释放锁**。同时线程进入**Timed Waiting**状态
       7. isInterrupted()--判断是否被打断，不会清除 打断标记
       8. interrupted()--判断当前线程是否被打断，会清除 打断标记
       9. **interrupt()** --打断线程，如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并**清除打断标记** ；
       	 如果打断的正在运行的线程，则会设置 打断标记 ；park 的线程被打断，也会设置 打断标记
       10. **yield（）**--提示线程调度器让出当前线程对CPU的使用。 会让线程进入 Runnable 就绪状态
    

11. sleep()和wait()的区别

    1. 两者最主要的区别在于：sleep ⽅法没有释放锁，⽽ wait ⽅法释放了锁 。
    2. 两者都可以暂停线程的执⾏，但sleep 不需要强制和 synchronized 配合使用，但 wait 需要和 synchronized 一起用
    3. Wait 通常被⽤于线程间交互/通信，sleep 通常被⽤于暂停执⾏。sleep 是 Thread 方法，而 wait 是 Object 的方法
    4. wait() ⽅法被调⽤后，线程不会⾃动苏醒，需要别的线程调⽤同⼀个对象上的 notify() 或者notifyAll() ⽅法。sleep() ⽅法执⾏完成后，线程会⾃动苏醒。或者可以使⽤ wait(longtimeout)超时后线程会⾃动苏醒。

12. 守护线程：在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程，这种线程并不属于程序中不可或缺的部分，当非守护线程全部结束，守护线程也就终止了，通过**setDaemon(true)**方法来实现

13. 线程的状态
    1. 线程的五种状态（操作系统层面）
    
    1. 初始状态：仅是在语言层面创建了线程对象，还未与操作系统线程关联
    2. 可运行状态：（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
    3. 运行状态：指获取了 CPU 时间片运行中的状态，当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
    4. 阻塞状态：如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入
    阻塞状态，等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
    5. 终止状态：表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态
    2. 线程的六种状态（API层面）
    

    1. new：线程刚被创建，但是还没有调用 start() 方法
    2. RUNNABLE:java线程将就绪和运行两种状态称作Runnable
    3. BLOCKED ：阻塞状态，表示线程阻塞于锁，比如其他线程请求正在被持有的Synchronized同步锁时
    4. WAITING：等待状态，表示当前线程进入等待状态，表示当前线程需要其他线程的一些动作（通知和环形）
    5. TIMED_WAITING：超时等待，可以在指定的时间返回
    6. TERMINATED ：当线程代码运行结束