【JavaEE初阶】第三节.多线程基础篇

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

目录

文章目录

前言

一、认识线程 

 二、多线程程序

      2.1 第一个Java多线程程序 

      2.2 怎么样观察线程的详细情况  

      2.3 sleep方法 

      2.4 run 和 start 方法的区别是什么 

三、创建线程

      3.1 继承 Thread类

      3.2 实现 Runnable接口

      3.3 使用 匿名内部类 来创建线程 

      3.4 使用Runnable接口,以匿名内部类的方式创建线程

      3.5 使用Lambda表达式创建线程(推荐做法)

四、多线程的优点 

五、多线程的使用场景

总结



前言

今天我们将进入到多线程基础的学习中,本节内容我们将对线程有一定的了解,学会掌握创建线程以及了解线程的优点等等,就让我们一起进入到今天的学习当中吧!!!!!!!!


提示:以下是本篇文章正文内容,下面案例可供参考

一、认识线程 

首先我们需要知道,为啥要有多个进程呢?

那是因为我们要 并发编程(CPU 单个核心已经发展到极致了,要想提升算力,就得使用多个核心)

引入 并发编程,最大的目地就是为了能够充分的利用好 CPU 的多核资源(如果在写代码的时候,不去处理一下,默认只会用到一个核心,造成资源浪费)

使用 多进程 这种模型,是可以完全做到 并发编程,并且也能够使 CPU 多核被充分利用!!!

但是,在有些场景下,会存在问题:

如果需要频繁的创建/销毁进程,这个时候就会比较低效!!!

例如,写了一个服务器,服务器需要同一时刻 给很多客户端提供服务的;此时,就需要使用到 并发编程 了

典型的做法,就是每个客户端给他分配一个进程,提供一对一的服务;客户端来了,就需要创建进程;客户端走了,就需要销毁进程

如果客户端来来回回很多,就需要 频繁的创建/销毁进程,这样就会比较低效;

创建/销毁进程,本身就是一个比较低效的操作:

  1. 创建 PCB
  2. 分配系统资源(尤其是 内存资源)
  3. 把 PCB 加入到内核的双向链表中

其中,分配资源 就已经是特别需要消耗时间了;

由于频繁的创建/销毁进程,是一件比较低效的事情;所以,就引入了 "线程";线程 也叫做 "轻量级进程"

说明:

一个线程其实是包含在进程之中的(一个进程里面可以有多个线程)

每个线程也可以有自己的 PCB (所以 一个进程里面可能对应多个 PCB) 

同一个进程的多个线程之间,共用一份系统资源(这就意味着 新创建的线程,不必给他分配系统资源,只需要复用之前的即可,即 上述的分配资源的操作,就不需要再进行了)

因此,创建线程只需要做到:

  1. 创建 PCB
  2. 把 PCB 加入到内核的链表中

这就是 线程相对于进程做出的重大改进,也是进程更 "轻量" 的原因!!!

举例说明:

张三家里是开厂子的,最近几年来生意非常好,需求的订单比较多,于是他准备扩建一下

现在有两种方案:

  1. 再次建造一个相同的工厂
  2. 在原来的工厂里面 新增加一条生产线即可

两个方案都可以以相同的效率生产产品,但是 很明显,方案1所需要的成本更高一些

如果可以把进程就可以看作是 工厂,那么线程就可以看成是 生产线

方案1表示多进程实现并发编程,方案2表示多线程实现并发编程

但是,使用多线程是能够提高效率,前提是多核资源必须是要充分的

如果 随着线程数量的增加,CPU 核心都被吃满了,那么 此时再继续增加线程,就已经没有意义了

这个时候速度不会进一步增加,反而会因此额外增加调度的成本(可以想象一下 工厂的生产线也不可以一直的增加下去,工厂的所占的空间满了咋搞,万一生产线之间太挤而会影响效率又咋搞)

总结:

  1. 线程,是包含在进程内部的 "逻辑执行流"(线程可以执行一段单独的代码,多个线程之间 是并发执行的)
  2. 操作系统进行调度的时候,其实是以 "线程为单位" 来进行调度的,换句话来说,系统内核不认 进程/线程,只认PCB(一个线程对应一个 PCB,一个进程对应 一个或多个 PCB)
  3. 进程里的线程的数量不可以无限增加,效率不会越来越高
  4. 创建线程的开销要比创建进程的开销要小,销毁线程开销要比销毁进程的开销要小
  5. 进程间是独立的,每个进程都有独立的虚拟地址空间,一个进程崩溃不会影响其余的进程;但是在同一个进程中,多个线程是共用一块资源,一个线程崩溃,这个进程中的所有线程都会崩溃
  6. 进程之间有隔离性,线程之间没有隔离性
  7. 进程是操作系统中 资源分配 的基本单位,线程是操作系统中 调度执行 的基本单位

 二、多线程程序

【JavaEE初阶】第三节.多线程基础篇_第1张图片

即使是一个最简单的 hello world,其实在运行的时候也涉及到 "线程" 了;一个进程里面至少有一个线程

运行这个程序,操作系统就会创建一个 Java进程,在这个 Java进程 里就会有一个线程(主线程)调用 main方法~

虽然在上述代码中,我们没有手动的创建其他线程,但是 Java进程 在运行的时候,内部也会创建出多个线程

2.1 第一个Java多线程程序 

Java中创建线程,离不开一个关键的类 —— Thread;

一种创建线程的方式,写一个子类,继承 Thread,并且重写其中的 run方法:

【JavaEE初阶】第三节.多线程基础篇_第2张图片

当然,如果仅仅是创建了一个类,还不可以说是 创建了线程,还得要创建实例才可以: 

【JavaEE初阶】第三节.多线程基础篇_第3张图片

可以这样来理解:

重写的 run方法 —— 先把新员工的任务准备好;

Thread t = new MyThread(); ——  招聘来了一个新员工 t,把任务交给他了(但是还没有开始干活);

t.start(); —— 开始干活

即:使用 new 创建线程对象,线程并没有被创建,而是仅仅创建了一个线程对象,运行 start 方法 时才会创建线程,并执行 run 方法

第一个Java多线程程序的代码 

package thread;

class MyTread extends Thread {
    @Override
    public void run() {
        //run方法本来是 Thread内部所提供的方法
        //这个 run方法 重写的目的,是为了明确,新创建出来的线程,是要干什么的
        System.out.println("hello thread");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //创建MyThread线程对象,但是线程没有创建
        Thread t = new MyTread();
        t.start();
        //t.start() 才是真正的开始创建线程,
        // 在操作系统内核中,创建出对应线程的 PCB,然后让这个 PCB 
        // 加入到系统链表中 参与调度,出现的线程就会执行上面的 run方法
    }
}

运行结果:

【JavaEE初阶】第三节.多线程基础篇_第4张图片

2.2 怎么样观察线程的详细情况  

如果我们此时在 主函数中添加这样一句代码:

【JavaEE初阶】第三节.多线程基础篇_第5张图片

那么,此时的运行结果是: 

【JavaEE初阶】第三节.多线程基础篇_第6张图片

明明是先执行了线程,后打印的"hello main",但是 为什么结果却是 先打印出来 "hello main",后打印的"hello thread" 呢?

  1. 每个线程都是独立的执行流!换句话说,main对应了一个执行流,MyThread对应了另一个执行流,这两个执行流之间是 并发 的关系;
  2. 此时两个线程执行的先后顺序,取决于操作系统 调度器 的具体实现;

程序猿可以把这里的调度规则 简单的视为 "随机调度",这个是改变不了的;

如果是想要控制哪个线程先执行,最多是让某个线程先等待,让另一个线程执行完了再执行;

所以,当程序运行的时候,先看到哪一个被执行的顺序 是不确定的;

虽然 可以在这里运行了许多次,先打印出来的是"hello main",但是顺序仍然是不可确定的,大概率是受到了创建线程自身的开销影响的;

当执行结果中出现了这一句话,就说明 进程已经结束了,并且退出码是 0:

就像 C语言中的 return 0;操作系统中用 进程的退出码 来表示进程的运行结果:

使用0表示进程执行完关闭,结果正确;使用 非0 表示进程执行完关闭,结果不正确;还有一种情况是 main还没有返回,程序就崩溃,此时返回的值很可能是一个随机值

当然,如果想要使进程不要结束的那么快,可以在 main方法 和 重写的run方法 使用死循环,让它们一直打印,这样就可以了

然后再执行结果中 是:"hello main" 和 "hello thread" 在交替打印,每一波都会打印几个,然后再打印下一波,当然 都是不确定的,打印那个内容,也都是调度器在进行控制;此时,就可以来查看 当前Java进程里面的线程的情况

可以在任务管理器中 看见Java进程的情况(需要把死循环的代码运行起来,不然嗖的一下就没了):

【JavaEE初阶】第三节.多线程基础篇_第7张图片

当然,此时是看不到 Java线程的,需要借助其他的工具 ;

在 JDK 里,提供了一个 jconsole 这样的工具,可以看到 Java进程里面的线程的详情;

【JavaEE初阶】第三节.多线程基础篇_第8张图片

运行 jconsole 之后,就可以看到 线程的情况了: 

【JavaEE初阶】第三节.多线程基础篇_第9张图片

注意:如果在打开 jconsole 之后,如果显示不到 本地进程的管理列表,那么可以退出,然后右键 选择使用管理员的方式运行;

【JavaEE初阶】第三节.多线程基础篇_第10张图片

【JavaEE初阶】第三节.多线程基础篇_第11张图片

【JavaEE初阶】第三节.多线程基础篇_第12张图片

2.3 sleep方法 

如果想要线程来适当的 "休息" 一下,为了方便观察,不要让刚刚的死循环代码 打印 "hello main" 和 "hello thread" 打印的太多太快,我们可以用 sleep 来进行操作;

sleep 是 "休眠" 操作,指定让线程摸一会儿鱼,不要上 CPU 上干活,参数单位是 毫秒;

使用 Thread.sleep 的方式进行休眠,sleep 是 Thread 的静态成员方法,直接通过 类名.方法名 的方式调用;

注意时间单位的换算

1秒 = 1000毫秒,1毫秒 = 1000微秒,1微秒 = 1000纳秒,1纳秒 = 1000皮秒;

秒(s)、毫秒(ms)、微秒(us)、纳秒(ns)、皮秒(ps);

由于计算机算得快,所以常用的单位是:ms、us、ns这几个单位;

【JavaEE初阶】第三节.多线程基础篇_第13张图片

Interrupted 中断!!!

sleep(1000)就是要休眠 1000毫秒,但是 在休眠过程中,可能有一点点意外 把线程给提前唤醒 —— 该异常唤醒的

 【JavaEE初阶】第三节.多线程基础篇_第14张图片

当然,用同样的方法 处理一下 main方法里面的,就可以很清楚的看到 最终打印的结果是按照自己设定的样子进行的(博客写不了按照时间运行的过程,就不去展示了)

代码结果:

【JavaEE初阶】第三节.多线程基础篇_第15张图片

2.4 run 和 start 方法的区别是什么 

start 方法:

run 方法 :

解析:

所以我们可以很清楚的看到,直接调用 run方法,并没有创建新的线程,而只是在之前的线程中,执行了 run方法里面的内容;使用 start方法,则是创建了新的线程,新的线程里面会调用 run方法,新线程和旧线程是并发执行的关系;

三、创建线程

3.1 继承 Thread类

如上面所介绍过的,创建一个类 继承 Thread,再重写 run方法

package thread;

class MyTread extends Thread {
    @Override
    public void run() {
        //run方法本来是 Thread内部所提供的方法
        //这个 run方法 重写的目的,是为了明确,新创建出来的线程,是要干什么的
        while(true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class Demo1 {
    public static void main(String[] args) {
        //一种比较朴素的创建线程的方式,是写一个子类,继承 Thread,重写其中的 run方法
        Thread t = new MyTread();
        t.start();
        }
    }
}

说明:

这个写法,线程 和 任务内容 是绑定在一起的;

3.2 实现 Runnable接口

创建线程,还可以创建一个类,实现 Runnable接口,再重写 run方法

package thread;

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class Demo2 {
    public static void main(String[] args) {
        //创建线程
        Runnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();

        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

【JavaEE初阶】第三节.多线程基础篇_第16张图片

 分析:

【JavaEE初阶】第三节.多线程基础篇_第17张图片

 

此处创建的 Runnable,相当于是定义了一个 "任务"(代码要做什么);

还是需要 Thread实例,把任务交给 Thread;

还是需要 Thread.start 来创建具体的线程;

说明:

这个写法,线程和任务是分离开的,可以更好的解耦合,"高内聚 低耦合",因此 使用实现 Runnable接口的方法更优;

把任务内容 和 线程 本身分离开了,即 任务的内容和线程的关系不大;

假设这个任务不想通过多线程的方式执行了,想通过别的方式来执行,这个时候代码改动也不大;

3.3 使用 匿名内部类 来创建线程 

我们也可以仍然继承 Thread类,但是不在是显式继承,而是使用 "匿名内部类" 来创建线程;

package thread;

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t.start();
    }

运行结果:

【JavaEE初阶】第三节.多线程基础篇_第18张图片

分析:

【JavaEE初阶】第三节.多线程基础篇_第19张图片

红色框框里面的内容,创建了一个匿名内部类(没有名字),这个匿名内部类是 Thread 的子类,同时前面的 new 关键字,就会给这个匿名内部类创建出了一个实例

这一套操作,继承、方法重写、实例化 一条龙服务

在 start 之前,线程只是准备好了,并没有真正的被创建出来,执行了 start方法,才真正在操作系统中创建了线程;

Thread 实例是 Java 中对于线程的表示,实际上要想正真跑起来,还需要操作系统里面的线程;

创建好了 Thread,此时操作系统里面还没有线程,直到调用 start方法,操作系统才真的创建了线程(创建 PCB,并且把 PCB 加入到链表里),并且进行执行起来;

3.4 使用Runnable接口,以匿名内部类的方式创建线程

package thread;

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();
    }
}

 运行结果:

【JavaEE初阶】第三节.多线程基础篇_第20张图片

3.5 使用Lambda表达式创建线程(推荐做法)

package thread;

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

 运行结果:

【JavaEE初阶】第三节.多线程基础篇_第21张图片

说明:

使用 lambda表达式,其实是更简单的写法,也是推荐写法;

形如 lambda表达式这样的,能够简化代码编写的语法规则,称为 "语法糖";

四、多线程的优点 

单个线程,串行的,完成 20 亿次自增:

package thread;

public class Demo6 {
    private static final long count = 20_0000_0000;
    private static void serial() {
        //serial 是 "串行" 的意思
        //需要把方法执行的时间给记录下来
        //记录当前的毫秒计时间戳
        long begin = System.currentTimeMillis();

        int a = 0;
        for(long i = 0; i < count; i++) {
            a++;
        }

        a = 0;
        for(long i = 0; i < count;i++) {
            a++;
        }

        long end = System.currentTimeMillis();
        System.out.println("单线程消耗的时间是 :" + (end-begin) + "毫秒");
    }

    public static void main(String[] args) {
        serial();
    }
}

运行结果:

【JavaEE初阶】第三节.多线程基础篇_第22张图片

多运行几次,取其平均值,所得的结果大概是:

单线程消耗的时间是:1070毫秒;

多个线程,并发的,完成 20 亿次自增

我们向 Demo6 中添加如下代码:

private static void concurrency() {
        //concurrency 的意思是 "并发"
        long begin = System.currentTimeMillis();
        Thread t1 = new Thread(() ->{
            int a = 0;
            for(long i = 0; i < count; i++) {
                a++;
            }
        });

        Thread t2 = new Thread(() ->{
            int a = 0;
            for(long i = 0; i < count; i++) {
                a++;
            }
        });

        t1.start();
        t2.start();

        long end = System.currentTimeMillis();
        System.out.println("多线程并发执行的时间:" + (end-begin) + "毫秒");
    }

这个代码,涉及到三个线程:t1、t2、main(调用 concurrency 方法的线程),三个线程都是并发执行的

即 t1、t2会开始执行,同时,可能不等t1、t2执行完,main线程就结束了,于是就结束计时

此处的计时,是为了衡量 t1 和 t2 的执行时间,所以正确的做法应该是等到 t1 和 t2 都执行完,才停止计时

所以在 创建线程的时候,还需要使用 jion方法

jion方法是等待线程结束(等待线程把自己的 run方法执行完)

所以还需要在 t1 和 t2 创建线程后 加上:

--加在 t2.start(); 之后
 
       try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

并此时可以在 mian方法中调用 concurrency() 方法

运行结果:

【JavaEE初阶】第三节.多线程基础篇_第23张图片

并同时执行多次 取其均值,我们可以发现,并发执行的时间的平均值 在 600 毫秒左右;

所以,相比之下,我们可以知道,多线程的效率确实是提高不少;

当然,如果在任务量不大的情况下,可能多线程并不会比单线程有太大的优势,毕竟线程的创建也是有开销的嘛;

五、多线程的使用场景

(1)在 CPU 密集型场景

代码中的大部分工作,都是在使用 CPU 进行运算(如 上面的反复 ++ 运算),此时使用 多线程 就可以更好的利用 CPU 多核计算资源,从而提高效率

(2)在 IO 密集型场景

I : input 输入

O : output 输出

如 读写硬盘、读写网卡......这些都算 IO

这些场景里,就需要花很大的时间等待

像这些 IO 操作,都是几乎不消耗 CPU 就能快速的完成读写数据的操作,既然 CPU 在摸鱼,就可以找点活干,可以使用多线程,避免 CPU 过于闲置

这就好比去食堂打饭,但是人多要排队,排队的过程就是等待(类似于 等待IO结束),于是 顺便拿出一本书来学习

(当然,我相信更多的同学会掏出手机刷视频)

总结

今天的内容就分享到这里了,下一节我们将更多了解有关多线程的知识,更加深入的进行学习,就让我们下一节内容再见吧!!!!!!!!!!!!!!

【JavaEE初阶】第三节.多线程基础篇_第24张图片

 

你可能感兴趣的:(JavaEE初阶,javaee,开发语言,多线程)