java多线程之--(1)深入理解多线程的原理以及使用线程的方法--(原理图+内存图)

我们在设计程序的时候,只能保证程序执行单一任务,那么如何让程序多样化的运行呢,比如说现在设计一个程序,可以一边吃饭一边看电视剧,我们要怎么设计呢,这就运用到了多线程

1.并发和并行

• 并发: 指两个或多个事件在同一时刻发生(同时发生)
• 并行: 指两个或多个事件在同一个时间段内发生

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每 一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分 时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行， 即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并行处理的程序越多，能大大的提高电脑运行的效率。

2.线程调度

计算机只有一个CPU时(单核),在任意时刻只能执行一条计算机指令,每一个线程只有获得CPU的使用权才能执行指 令。所谓多线程并发运行,从微观上看,其实是各个线程轮流获得CPU的使用权,分别执行各自的任务。那么,在可运行 池中,会有多个线程处于就绪状态等到CPU,JVM就负责了线程的调度。JVM采用的是抢占式调度,没有采用分时调度, 因此可以能造成多线程执行结果的的随机性。

3.线程和进程

进程: 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多 个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

进程图解

线程: 进程内部的一个独立执行单元,来完成进程中的某个功能 ,一个进程可以同时并发的运行多个线程，可以理解为一个进程便相当于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。

线程图解

进程与线程的区别

• 进程: 有独立的内存空间，进程之间数据存放空间（堆空间和栈空间）是独立的,每个进程至少有一个线程。
• 线程: 一个进程中多个线程共享堆空间，栈空间是独立的，线程消耗的资源比进程小的多

4.继承Thread创建线程

• 自定义线程类 MyThread

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:02
 */
public class MyThread  extends Thread{

    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println("新的线程: "+i);

        }
    }
}

• 测试类

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:02
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        for (int i = 0; i < 10; i++){
            System.out.println("main线程: "+i);
        }
    }
}

5.实现Runnable接口创建多线程

• 自定义Runnable任务类 MyRunnable

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:16
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}

• 测试类

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:16
 */
public class RunnableDemo {
    public static void main(String[] args) {
        // 创建自定义的任务类
        MyRunnable runnable = new MyRunnable();

        // 创建线程 指定启动时要执行的任务 也就是Runnable类 这里指定线程名字为 Runnable
        Thread thread = new Thread(runnable, "Runnable");
        thread.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main " + i);
        }
    }
}

• 这里不贴执行结果了,自己运行一下就知道了,没有保证线程安全,输出的内容都是随机的

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。 在启动的多线程的时候，需要先通过Thread类的构造方法

Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。 实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程 编程的基础

6.使用匿名内部类实现Runnable接口

我们不用匿名内部类使用接口的时候需要进行以下几个步骤

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

这样就太繁琐了,我只是想使用一个方法,但是要经过这么多步骤,那能不能简化一下呢,匿名内部类就是这么做的

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:31
 */
public class NoNameInnerClassThread {
    public static void main(String[] args) {
        // 匿名创建了一个Runnable类
        //  这一步相当于上面例子中 new MyRunnable整个过程
        Runnable runnable = new Runnable(){
            public void run(){
                for (int i = 0; i < 10; i++) {
                    System.out.println("Runnable: "+ i);
                }
            }
        };

        // 创建Thread类 ,把Runnable任务类交给Thread执行
        new Thread(runnable).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main " + i);
        }

    }
}

7.两种方式创建线程的区别

实现Runnable接口比继承Thread类所具有的优势：

1. 可以避免java中的单继承的局限性
2. 实现解耦操作，任务可以被多个线程共享，任务和线程独立
3. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩展:
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

8.多线程原理和内存图

• 先写个Demo,自定义线程类 MyThread

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:02
 */
public class MyThread  extends Thread{

    /*
    * 利用继承中的特点,将线程名称传递进行设置
    * */
    public MyThread(String name){
        super(name);
    }

    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println(getName()+i);
        }
    }
}

• 测试类

/**
 * @Description
 * @auther 宁宁小可爱
 * @create 2020-01-10 13:02
 */
public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println("这里是Main线程......");

        MyThread thread = new MyThread("小强");
        thread.start();

        for (int i = 0; i < 20; i++){
            System.out.println("旺财: "+i);
        }
    }
}
运行结果: 这里太多了裁剪掉一些打印信息

这里是Main线程......
旺财: 0
旺财: 1
旺财: 2
旺财: 16
旺财: 17
旺财: 18
小强4
旺财: 19
小强5
小强6
小强7
小强8
小强9
小强10
小强11
小强17
小强18
小强19

流程图

同一时间内，CPU只能处理1条线程，只有1条线程在工作（执行）;多线程并发（同时）执行，其实是CPU快速地 在多条线程之间调度（切换）。如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象。 程序启动运行main时候，java虚拟机启动一个进程，其中有一个主线程(main方法调用时候被创建)。随着调用mt 的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行

内存图

以上个程序为例，进行图解说明： 多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈,当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了,那么进程就结束了。