线程与进程知识入门（一）

线程与进程知识入门（二）
线程与进程知识入门（三）

线程与进程概念

   进程是内存中一个运行中的应用程序，是系统运行程序的基本单位(系统进行资源<CPU、内存、磁盘I/O>分配的最小单位)。进程与进程之间是相互独立的。一个进程中可以有多个线程，线程之间是可以相互影响的，可以有关系的。进程本身是不执行任务的，真正执行任务的是线程。
   一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。二，进程是一个“运行的应用程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程，简单理解就是让执行的代码（程序定义：程序是指令和数据的有序集合）跑起来之后就是一个进程
   线程是CPU调度的最小单位。必须依赖进程存在，不能独立于进程而存在。线程可以共享所在进程的资源（CPU、内存、磁盘I/O)；一个进程中至少存在一个线程，否则空进程没有任何意义；在引入线程的操作系统中，通常把进程作为分配资源的基本单位，把线程作为独立运行和调度的基本单位；

线程和进程的区别

进程：有独立的内存空间，进程中数据存放的空间（堆，栈）是独立的，至少有一个线程
线程：堆空间是共享的，栈空间是独立的，线程的资源消耗比进程小，也可以互相影响；因为一个进程中多个线程是并发进行的，真正意义上是有先后顺序的，谁先谁后完全取决于CPU的调度（CPU的时间片轮转机制），也可以反过来看做是线程抢占CPU，谁抢到了，谁就执行任务，也造就了多线程的随机性。

CPU时间片轮转机制

系统运行的时候，CPU会分成很多个时间片，当有进程或者线程执行的时候，系统会分配给你时间片，CPU就可以执行进程/线程，当分配给你的时间用完了，这时候就需要让出 CPU，释放相应的资源给下一个获得时间片 的进程/线程使用，这就是所谓的上下文切换；
CPU执行一条指令的时间大概是0.6ns，一次上下文切换大概需要花费2w个CPU周期，相对来说是非常消耗CPU时间的； 并发编程的时候要尽可能的减少上下文切换

并发&并行

并发指单位时间内执行多任务（逻辑上的同时），实际上并不是同时执行，只是给人的错觉几乎同时执行的；
并行指多个任务可以在同一时刻执行（物理意义上的同时）

• 一个咖啡机，2支队伍排队（可以理解为2个任务）；一分钟内可以生产10杯咖啡（可以理解成完成10次任务的处理），这10杯咖啡，是一杯一杯的生产出来的，这就是所谓的并发
• 2个咖啡机，2支队伍排队（可以理解为2个任务）；同一个时间点，可以生产出2杯咖啡（2个任务可以在同一个时间点进行处理），这就是所谓的并行

为什么要使用多线程

先从总体上说：

• 从计算机底层来说： 线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。
• 从当代互联网发展趋势来说： 现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。

深入计算机底层探究：

• 单核时代： 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时，IO 设备空闲；进行 IO 操作时，CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样两个的利用率就可以在理想情况下达到 100%了。
• 多核时代: 多核时代多线程主要是为了提高 CPU 利用率。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。

线程启动的几种方式

官方文档明确指出线程的启动方式有2种

1. 第一种：继承Thread类，new出实例，然后调用start()方法

static class MyThread extends Thread {
        @Override
        public void run() {
            // 任务逻辑
        }
    }
new MyThread().start();

2. 第二种：实现Runnable接口

class MyRunnable implements Runnable{

        @Override
        public void run() {
			// 任务逻辑
        }
    }
new Thread(new MyRunnable()).start();

Thread和Runnable的区别

Thread是真正意义上对线程的抽象
Runnable是对任务（业务逻辑）的抽象，最终还是需要交给Thread去执行
由于Java的单继承多实现的特性，使得实现Runnable比继承Thread更加灵活一些，而且Runnable一个实例可以给多个线程同时使用，提高了复用性

如何让线程安全的终止

interrupt()、isInterrupted()、interrupted()、stop、destroy …

• jdk里面明确标注此类方法废弃，不建议使用，原因：此类方法过于野蛮、强制，当你调用了stop、destroy等方法的时候，线程会无条件的终止，这样就容易导致一些资源无法正常释放；
• interrupt()对线程进行中断，会给线程的标志位赋值true，这在线程里面是协作式的，不会强制执行，类似于你给线程打了一个招呼，至于线程会不会理会你取决于线程本身，线程可以听你的去中断，也可以不理会你 他继续执行
• isInterrupted()：用来判断当前线程是否被中断，标志位不会变化（标志位依然是true）
• interrupted()：用来判断当前线程是否被中断，标志位会被恢复（标志位会变成false）

注：中断异常对线程中断的影响：如果线程抛出InterruptException，并且有try catch 捕获到异常，这时候，中断标志位就会被置为false，如果想继续中断线程，可以在catch里面继续调用一次interrupt()方法，这样就会再次把中断标志位置为true
阻塞线程需要抛出异常，这样设计的原因：类似于stop()方法一样，如果没有抛出异常（在异常里面把中断标志位置为false），那么线程就彻底的中断了，程序员就没有机会去处理线程所占用的资源

        @Override
        public void run() {

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {// 这里面会把中断标志位为置成false
                // Thread.currentThread().isInterrupted();此时已经为false
                // 这时候 程序员可以在此处做一些处理，比如资源释放
                // 然后手动调用 interrupt()方法，
                // Thread.currentThread().isInterrupted();此时已经为true,线程中断
                e.printStackTrace();
            }

        }

线程死锁状态下不会理会中断标志

对java里面的线程在多一点点的认识

线程的常用方法和线程的状态

• start() 真正线程启动的方法
• run() 可以看成普通类的一个普通成员方法，可以重复调用

new Thread(),只是创建了一个线程的实例，并没有跟线程有关联；
只有调用了start()方法的时候，才真正的跟线程挂钩；

Thread类，只能执行一次start()方法，如果执行多次，会抛异常，见源码

每次执行start()方法的时候，都会先判断一下线程的状态，如果已经运行了，就会抛出异常。

线程的状态图

• yield() :当前线程让出CPU的执行权，空出CPU的时间片，此时，操作系统会重新分配CPU的时间片（在所有的线程中随机分配，当然你刚刚让出时间片的线程也有可能会被重新分配到时间片，继续执行）

注意：yield() 只会让出CPU的执行权，并不会让出其持有的锁、资源；

• join():用于多线程的时候，当A线程正在执行的时候，B线程调用了join()方法，此时A线程会挂起，把执行权让给B线程，等到B线程执行完之后，A线程才会接着执行。
  可以让线程串行的执行

synchronized 关键字（内置锁）

解决多个线程之间访问资源的同步性，保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

• 对象锁（修饰普通方法、代码块）
• 类锁（修饰静态方法）

使用方式

1. 给普通方法加锁:作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁

    synchronized void method(){
        
    }

2. 修饰代码块：指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码块前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得当前class的对象锁

     void method() {
         synchronized (this) {

         }
     }

3. 修饰静态方法：在类加载的时候，在虚拟机里面都有一个对应的class对象，这个时候锁的内容就是这个class对象，其本质还是对象锁

     synchronized static void method() {
        
     }

锁：关于线程安全的问题，就看这个锁是不是同一把锁，只要是同一个对象锁的时候，只有一个线程可以执行

volatile关键字

最轻量级的同步机制
可以保证多线程下变量的可见性
但是不能保证多线程的安全性，即“一写多读”
一个线程对volatile修饰的变量进行写的时候，可以及时的让其他线程能够读取写之后的新值，这就是所谓的可见性；

线程与进程知识入门（二）