进程与线程

进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 。当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。

进程可以视为程序的一个实例。

大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 。

Google浏览器可以多开,每个浏览器实例是线程还是进程？

答案是:进程,当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程,进程可以视为程序的一个实例。

线程

一个进程之内可以分为一到多个线程。

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行 。

Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。

在 windows 中进程是不活动的，只是作为线程的容器。

线程&进程对比

进程

进程基本上相互独立的，而线程存在于进程内，是进程的一个子集。

进程拥有共享的资源，如内存空间等，供其内部的线程共享。

进程间通信较为复杂 同一台计算机的进程通信称为IPC(Inter-process communication) 。

不同计算机之间的进程通信称为RPC，需要通过网络，并遵守共同的协议，例如 HTTP协议 。

在同一个JVM进程中,有且只有一个进程,就是它自己,也就是说JVM是一个进程,启动JVM,等于启动了一个应用程序,也就是启动了一个进程。

线程

线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量。

线程更轻量，线程上下文切换成本一般上要比进程上下文切换低。

并行与串行

串行:程序一个一个按顺序执行。

并行:多个程序同时执行。

单核 cpu 下，线程实际还是串行执行的,如果只有单核cpu，多进程并行并没有提高效率。

操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，给人类的感觉是同时在运行 。

总结为一句话就是： 微观串行，宏观并行,一般会将多个线程轮流使用 CPU 的做法称为并发即concurrent。

并行与并发

家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这些事，先烧热水,然后做饭、打扫卫生，最后喂奶这就是并发 。

强调的是单核cpu轮流做多件事情。

家庭主妇雇了3个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行 。

强调的是多核cpu轮流做多件事情。

多进程的意义:提高CPU的使用率

多进程可以达到多核cpu同时做多件事的目的。

多线程的意义:提高应用程序的效率

多线程可以达到多个线程轮流使用CPU的目的。

JVM启动是多线程:主线程+垃圾回收线程

A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。

B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。

C:JVM是一个进程

线程的调度

a:分时调度(平均使用)

b:抢占式调度 (Java的调度方式)

线程的优先级:10最高,1最低

a:默认是5

b:范围是1到10

线程优先级会提示调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它.优先级越高,被调用到的可能性越大，但也仅仅只是可能。

如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但cpu闲时，优先级几乎没作用

★线程的生命周期

A:新建 ​ B:就绪 ​ C:运行 ​ D:阻塞 ​ E:死亡

★线程状态转换图

应用之异步调用

以被调用方角度来讲

被调用方需要等待结果返回，才能响应就是同步

被调用方不需要等待直接返回就是异步。

多线程可以让方法执行变为异步的（即不要巴巴干等着）

比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停。

-在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程。

-tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程。

-ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

应用之提高效率

充分利用多核 cpu 的优势，提高运行效率。想象下面的场景，执行 3 个计算，最后将计算结果汇总。

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms

但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms

注意

需要在多核 cpu 才能提高效率，单核仍然时是轮流执行并且由于单核增加了上下文切换的开销,所以反而可能更慢。

结论:多线程可以提高效率

单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用cpu ，不至于一个线程总占用 cpu，别的线程没法干活

多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的,有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任务都能拆分（参考【阿姆达尔定律】）也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义。

IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一直等待 IO 结束，没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化。

创建和运行线程

方法一:继承 Thread

查看Thread的源码,可以发现Thread不仅实现了Runnable接口,并且存在1个成员变量Runnable target。

public class Thread implements Runnable {
   private volatile String name; 
   private Runnable target;
  @Override
    public void run() {
        //如果target不为空,使用target的run方法
        //否则使用子类的run方法
        if (target != null) {
            target.run();
        }
    }
}

我们可以继承Thread类,重写Thread的run方法

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
​
    public static void main(String[] args) {
        // 创建线程对象
        String name = "emanon";
        MyThread thread = new MyThread(name) {
            //因为Thread继承自runnable
            @Override
            public void run() {
                // 要执行的任务
            }
        };
        // 启动线程
        thread.start();
    }
}

方法二:使用Runnable+Thread

查看Thread的源码,可以发现Thread不仅实现了Runnable接口,并且存在1个成员变量Runnable target。

public class Thread implements Runnable {
   private volatile String name; 
   private Runnable target;
  @Override
    public void run() {
        //如果target不为空,使用target的run方法
        //否则使用子类的run方法
        if (target != null) {
            target.run();
        }
    }
}

把【线程】和【任务】分开,Thread代表线程,Runnable 代表运行的任务

// 创建任务对象
Runnable task = new Runnable() {
 @Override
 public void run() {
 System.out.println("hello");
 }
};
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread thread = new Thread(task, "emanon");
thread.start();

Java 8 以后可以使用lambda 精简代码

// 创建任务对象
Runnable task2 = () -> System.out.println("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread thread = new Thread(task, "emanon");
thread.start();

方法三:FutureTask+Runnable配合Thread

public class FutureTask<V> implements RunnableFuture<V> 
​
public interface RunnableFuture<V> extends Runnable, Future<V> 

public FutureTask(Runnable runnable, V result) {
        //通过适配器将runnable适配为callable
        
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       
    }

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
            //RunnableAdapter 实现了 callable接口
            //在RunnableAdapter#call方法中调用Runnable#run 同时返回result
        return new RunnableAdapter<T>(task, result);
    }

static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

FutureTask 能够接收 Runnable 类型的参数，用来处理有返回结果的情况。

这里构造函数说明中提示到当Runnable 执行完毕之后可以用Future接口的get() 方法获取执行结果。

但是Runnable的run方法是void 的,没有返回结果,那这个result 有什么用呢??

实际上这个result 是由你设置好传进去的,FutureTask 只是在Runnable 执行完之后返回预先设置好的result,以便通知任务已完成。

​
public class MyFutureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建任务对象 方式1
        Integer result = 2;
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(1);
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<Integer>(runnable, result);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}
/***
    输出:
    1
    2
***/

方法四:FutureTask+callable配合Thread

上面的FutureTask+Runable虽然可以带返回值,但是带的返回值是提前固定的。

FutureTask还能够接收 Callable 类型的参数，用来处理有返回结果的情况。

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        //设置默认初始状态为NEW
        this.state = NEW;       
    }

public class MyFutureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建任务对象 方式2
        FutureTask<Integer> task = new FutureTask<>(() -> {
            System.out.println("hello");
            return 100;
        });
​
        // 参数1 是任务对象; 参数2 是线程名字
        new Thread(task, "emanon").start();
        // 主线程阻塞，同步等待 task 执行完毕的结果
        Integer result = task.get();
        System.out.println("结果是:" + result);
    }
}
/***
 输出:
 hello
 结果是:100
 ***/

方法五:FutureTask+callable配合线程池

public class MyFutureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(1);
        FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() {
                System.out.println("hello");
                return Integer.valueOf(100);
            }
        });
        service.submit(task);
        System.out.println(task.get());
    }
}
/***
 输出:
 hello
 结果是:100
 ***/

线程运行

观察多个线程同时运行

-交替执行

-执行先后顺序不由我们控制

查看进程线程的方法

windows

-任务管理器可以查看进程和线程数，也可以用来杀死进程

-task list 查看进程

-task kill 杀死进程

linux

-ps -ef 查看所有进程

-ps -f -p 查看某个进程（PID）的所有线程

-kill 杀死进程

-top 按大写 H 切换是否显示线程

-top -H -p 查看某个进程（PID）的所有线程

Java

-jps 命令查看所有 Java 进程

-jstack 查看某个 Java 进程（PID）的所有线程状态

-jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

-jconsole 远程监控配置

需要以如下方式运行你的 java 类

java -Djava.rmi.server.hostname=ip地址 -Dcom.sun.management.jmxremote -

Dcom.sun.management.jmxremote.port=连接端口 -Dcom.sun.management.jmxremote.ssl=是否安全连接 -Dcom.sun.management.jmxremote.authenticate=是否认证 java类

修改 /etc/hosts 文件将 127.0.0.1 映射至主机名

如果要认证访问，还需要做如下步骤

复制 jmxremote.password 文件

修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写

连接时填入 controlRole（用户名），R&D（密码）

原理之线程运行

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？

-其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

-每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

-每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

-默认的栈大小是1mb

-栈的数据结构是先进后出

线程上下文切换

-线程的 cpu 时间片用完

-垃圾回收

-有更高优先级的线程需要运行

-线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态。

以上一些原因会导致Context Switch。 cpu 不再执行当前的线程的代码，转而执行另一个线程的代码。Java 中对应的概念就是程序计数器，它是线程私有，它的作用是记住下一条 jvm 指令的执行地址，状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等。

注意:Context Switch 频繁发生会影响性能。