JavaEE:多线程(1):线程是啥?怎么创建和操作?

进程的问题

本质上来说,进程可以解决并发编程的问题

但是有些情况下进程表现不尽如人意

1. 如果请求很多,需要频繁的创建和销毁进程的时候,此时使用多进程编程,系统开销就会很大

2. 一个进程刚刚启动的时候,需要把依赖的代码和数据从磁盘加载到内存中

但是从系统分配一个内存不是件容易事情

申请内存的时候需要指定大小,系统内部把各种大小的空闲内存,通过一定的数据结构组织起来

实际申请的时候要去这样的空间中查找,找到大小合适的空间,再进行分配

所以引入一个概念,线程

线程

线程称为轻量级进程,保持进程的独立调度执行,同时省去了分配资源释放资源带来的额外开销

使用PCB描述一个线程

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第1张图片

多个线程的PCB的内存指针指向同一个内存空间

这意味着只用创建第一个线程的时候需要从系统分配资源,后续的线程就不必分配,直接共用前面的那份资源就可以了

除了内存之外,文件描述符表(硬盘资源)也是多个线程共用一份的

把能够进行资源共享的线程分成组,称为线程组

一个进程可以有1个PCB,也可以有多个PCB(意味着这个进程包含了一个线程组,也就是包含多个线程)

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第2张图片上面图中这多个线程合起来就是一个进程

进程和线程的关系

有线程之前,进程要扮演两个角色:资源分配的基本单位;调度执行的基本单位

有线程之后,进程专注于资源分配,线程专注于调度执行

例子:一个滑稽吃100只鸡,消耗的时间比较多

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第3张图片

第一个方案:搞两个房间,每个滑稽吃50只,速度大幅度增加

这个相当于多进程,创建新的进程就要申请更多的资源(房间和桌子)

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第4张图片

第二个方案,房间和桌子数量不变,但是滑稽数量增加到两个

这种就是多线程,资源开销更小 

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第5张图片

更多的滑稽,每个滑稽分到的鸡就更少了,但是速度更快了

但是线程分配越多越好吗?

当引入的线程达到一定数量之后,再继续引入线程就没办法提升了,因为线程之间会竞争CPU资源,但是CPU资源是有限的,非但提高不了效率,还会增加调度的开销

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第6张图片

而且多个线程之间会打架,可能导致代码中出现逻辑错误

这种就是线程安全问题

另外,多线程共享资源也有副作用,1号和2号滑稽抢鸡腿,1号抢到了,2号勃然大怒:都别吃了!直接把整个桌子给破坏了

也就是说,一个线程如果抛出异常而且没有处理好的话,可能会导致整个进程被终止

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第7张图片

总结一下

1. 进程包含线程

2. 每个线程是一个独立的执行流,可以执行代码并参与CPU调度中(每个线程都有状态,优先级,记账信息和上下文)

3. 每个线程都有自己的资源,进程中的线程共享一份资源

4. 进程和线程之间,不会相互影响。但是如果同一个进程中某个线程抛出异常,可能导致进程中其他线程异常终止

5. 同一个进程中的线程之间会互相干扰,引起线程安全问题

6. 线程太多会导致调度开销过多的问题


多线程编程

Java推荐多线程编程,系统提供了多线程编程的API

Java里一般把跑起来的程序称为进程,没有运行起来的程序(exe),称为可执行文件

一个进程里的第一个线程称为主线程,main方法就是主线程的入口

创建线程

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第8张图片

这里的run类似于main方法,是一个Java进程的入口方法;不需要程序员手动调用,会在合适的时机(线程创建好了之后),被JVM自动调用执行

这种风格的函数被称为回调函数

(回调函数是一种特殊的函数,它作为参数传递给另一个函数,并在被调用函数执行完毕后被调用)

为什么要override呢?

重写的本质是扩展现有的类,Thread标准库里面的run是不知道你的需求是什么,必须要手动指定

//1. 创建一个自己的类来继承Thread(在java.lang里面,自动导包)
class MyClass extends Thread{
    @Override
    public void run(){
        System.out.println("hello world");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        //2. 根据刚才的类创建出实例(线程实例才是真正的线程)
        Thread t = new MyClass();
        //3.调用Thread的start方法,才会真正调用API,在系统内核中创建出线程
        //对于同一个Thread对象来说,start只能调用一次
        t.start();
    }
}

操作系统的内核:操作系统最核心的功能模块,负责管理硬件,给软件提供稳定的运行环境

例子:

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第9张图片

我们平时运行的idea,qq音乐这些应用程序都是运行在用户态了

但是这些程序有时候需要针对一些系统提供的软硬件资源进行操作,这些操作需要调用系统的api,进一步在内核钟完成这样的操作

为什么要划分出用户态和内核态?

为了稳定,防止应用程序把硬件设备或者软件资源给搞坏了

系统封装了一些API,这些API属于合法操作,这些应用程序只能调用这些合法API,就不会被系统/硬件设备造成伤害

操作系统 = 内核+配套的应用程序


观察线程流

例子

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第10张图片

按照之前的理解,如果一个代码中出现两个死循环,最多只能执行一个,另一个循环就进不去了

但真正运行程序可以看到两个循环都在执行

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第11张图片

此处调用start创建线程之后,兵分两路;一路沿着main方法继续执行,打印hello main

另一路进入到线程的run方法,打印hello thread  

此时两个线程并发执行,但是这些线程执行的先后顺序是不确定

因为操作系统的内核中有一个调度器模块,这个模块的实现方式是一种类似于随机调度的效果

随即调度?(也是抢占式执行)

1. 一个线程什么时候被调度到CPU上执行,时机是不确定的

2.一个线程什么时候从CPU上下来,给别的线程让位,时机也是不确定的


不只是可以用打印来观察,我们还可以用jdk中的jconsole工具来进一步分析出线程流

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第12张图片

点进去,选择本地连接,连接到我们刚刚的程序中(注意刚刚的程序要运行起来才能在这里找到)

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第13张图片

 JavaEE:多线程(1):线程是啥?怎么创建和操作?_第14张图片

 JavaEE:多线程(1):线程是啥?怎么创建和操作?_第15张图片

一个Java进程中,包含的线程很多,除了我标出来的两个线程

其余的线程都是JVM自带的线程,进行一些垃圾回收,监控统计各种指标,把统计指标通过网络的方式传输给其他程序

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第16张图片


由于我们的程序中的两个循环都是死循环,循环体就单纯打印,一旦程序运行起来,这俩循环就会转地飞快;也会导致CPU占用率比较高,进一步提高电脑的功耗

我们可以在循环中加入一个Thread提供的静态方法sleep来降低循环速度

class MyThread2 extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread");
            try {
                sleep(1000);//每秒钟打印一次
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        Thread t = new MyThread2();
        t.start();

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

这里为什么不能直接用sleep(1000)呢?

因为sleep这个过程中可能被提前唤醒

为什么第一个sleep只有一个try catch的处理选项而不能throws,而第二个sleep可以throws异常?

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第17张图片

如果这里加上throws,修改方法签名,此时就无法构成重写了,因为父类的run没有throws这个异常,子类重写的时候就不能throws异常 

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第18张图片

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第19张图片

我们可以看见两个线程交替运行,而且先执行main还是thread是不一定的

但是,由于我们主线程main调用start方法之后就立即往下执行打印了,内核就要通过刚才线程的API构建出线程出来,并且执行run

因为线程创建本身就有开销,所以第一轮打印的时候,在创建线程开销本身的影响下,hello thread会比hello main慢一点打印出来


创建线程其他方式

上面是线程创建的第一种方式:继承Thread,重写run

下面介绍第二种方式:实现Runnable接口,重写run

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第20张图片

class MyThread3 implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("hello runnable");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo3 {
    public static void main(String[] args) {
        Runnable runnable = new MyThread3();//只是一段可执行的代码
        Thread t = new Thread(runnable);//还要搭配Thread类,才能真正在系统中创建出线程
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

这种写法其实就是把线程和要执行的任务进行了解耦合了


第三种写法:继承Thread,重写run,但是使用匿名内部类

写{ }意思是要定义一个类,这个新类继承自Thread,此处{ }中可以定义子类的属性和方法。这里最主要重写run方法

public class ThreadDemo4 {
    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();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

第四种方法:实现Runnable,重写run,实现匿名内部类

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

第五种方法:使用lambda表达式(推荐使用)

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第21张图片

Thread构造方法有好几个版本,编译器在编译的时候挨个往里匹配,其中匹配到Runnable这个版本的时候发现run方法无参数,正好能和lambda对上


Thread其他属性和方法

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第22张图片

Thread(String name) :自己创建的线程,默认是按照Thread-0 1 2 3 ...

给线程起名字不会影响线程执行,只是方便调试

⚠线程之间的名字是可以重复的

    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:多线程(1):线程是啥?怎么创建和操作?_第23张图片这里的“这是我的线程”就是刚刚创建的新线程


JavaEE:多线程(1):线程是啥?怎么创建和操作?_第24张图片

getId():JVM自动分配的身份标识,会保证唯一性

isDaemon:判断是否是守护线程(后台线程)

后台?

前台线程的运行会阻止进程结束

后台线程的运行不会阻止进程结束

观察我们上面的线程执行图,列表中已经没有main了,但是t仍在执行

此时的t就属于是前台线程,只要前台线程没执行完,进程就不会结束

把这个线程改成后台

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第25张图片

我们发现啥都没打印,说明后台线程无法阻止进程结束

JVM里其他线程都是后台线程

isAlive:表示内核中的线程PCB是否还存在

当我们输入t.start()的时候就真正在内核中创建出这个PCB,此时isAlive就是true

⚠Java定义的线程对象的生命周期和内核中的PCB生命周期是不完全一样的

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第26张图片


中断线程

让run()方法提前执行完毕,也就能提前终止线程了

    private static boolean isQuit = false;
    public static void main(String[] args) {
        //lambda表达式本质上就是函数式接口,也就是匿名内部类,内部类访问外部类成员天经地义
        Thread t = new Thread(()->{
            while(!isQuit){
                System.out.println("我是一个线程,工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程工作完毕");
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("让进程结束");
        isQuit = true;
    }

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第27张图片

上面的代码是让main线程打印完毕之后才会设置isQuit,t线程的循环才会结束

如果是先isQuit = true之后再打印“让进程结束”的话,是主线程先进行打印还是t线程先进性打印就不确定了

诶?那能不能把isQuit写进main函数里把它变成局部变量呢?

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第28张图片哦吼,编译出错!

lambda表达式讲过一个语法:变量捕获,可以访问到外面定义的局部变量。那为啥还报错??

看看这里的报错信息,访问到的局部变量得是final或者事实final修饰的

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第29张图片

根据报错信息,我们得在上面加一个final

但是下面的isQuit = true又报错了,因为final定义的变量不能修改

所以嘞,isQuit无法作为局部变量

再继续挖~为啥Java这里对于变量捕获有final的限制?

isQuit是局部变量的时候是属于main方法的栈帧中,但是Thread lambda是有自己独立的栈帧的

这样可能导致main方法执行完了,栈帧销毁了,同时Thread的栈帧还存在,还想用isQuit。因为变量捕获本质上是传参,也就是让lambda表达式在自己的栈帧中创建一个新的isQuit,并把外面的isQuit的值拷贝进来

Java为了防止isQuit不同步,干脆不让你修改isQuit,就是让你加个final


上面那样写还不够优雅,下面推荐一手更优雅的写法

Thread提供了这种方法,用于获取当前的线程实例t

public class ThreadDemo13 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            //isInterrupted 判定标志位
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("我是一个线程, 正在工作中...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完毕!");
        });

        t.start();

        Thread.sleep(3000);
        // 使用一个 interrupt 方法, 来修改刚才标志位的值,设置标志位
        System.out.println("让 t 线程结束");
        t.interrupt();
    }
}

t.interrupt相当于isQuit = true

但是上面的代码有一个报错异常,其实也是这里的interrupt导致sleep出现异常

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第30张图片

在在执行sleep的过程中,调用interrupt,大概率sleep的时间还没到,被提前唤醒了

提前唤醒的话程序会做两件事:

1. 抛出interruptedException(接着被catch到)

2. 清除Thread对象的isInterrupted标志位(sleep清除的)

sleep(1000),可能1000ms都没到就要终止线程,相当于前后两个矛盾的操作;

所以sleep清除标志位可以给程序员更多的可操作空间:

1)让线程提前结束(加break)

2)让线程不结束,继续执行(不加break)

3)让线程执行一些逻辑之后再结束(写其他代码再break)

要想让进程结束,只需要在catch里面加上break就行了

不想要打印异常信息就把这一行注释掉就行了

实际开发中,catch里面需要写什么代码?

1. 尝试自动回复的程序

2. 记录日志(非严重的问题)

3. 发出报警(严重问题)

4. 少数正常业务逻辑(比如文件操作)


等待线程

前面提到,多个线程底层的执行顺序是不确定的

但是我们可以在应用程序中,通过一些api来影响线程的执行顺序

join关键字:影响线程结束的先后顺序

实现t2线程等待t1线程,就要让t1先结束,t2后结束;join可以使t2线程阻塞

t.join();

在main线程中调用上面这个代码,意思是让main线程等待t线程结束(t执行,main阻塞)

具体来说,执行join的时候会先看t线程是否正在运行,如果t运行中,main线程就会阻塞

t运行结束,main线程就会从阻塞状态恢复,继续往下执行


练习:让主线程创建一个新线程,由新线程负责1+2+...+1000的运算

public class ThreadDemo15 {
    private static int result = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            for (int i = 0; i <= 1000 ; i++) {
                result += i;
            }
        });
        t.start();
        //使用sleep,但是不知道t线程要执行多久,sleep里面的时间不好填
        //Thread.sleep(1000);

        //使用join,严格按照t线程执行结束来作为等待条件
        //什么时候t运行结束,什么时候join结束等待
        t.join();

        System.out.println("result: " + result);
    }
}

如果数据量大一点,可能这个线程就会计算的很慢,比如

i <= 10_0000_0000L

我们可以分多几个线程一起计算

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第31张图片

三个线程兵分三路,并发执行(并发 = 并行(t和t2在两个不同核心上同时执行)+并发(t和t2在同一个核心上分时复用执行))

关于join的细挖

JavaEE:多线程(1):线程是啥?怎么创建和操作?_第32张图片

第一个join是死等,就一根筋一定要等到你的t线程执行完才能继续下一个线程

第二个是带有超时时间的等,等有一个时间上限的(超时时间),如果等待的时间超时了,那就不等了


获取线程引用

如果是继承Thread,直接使用this拿到线程实例

class MyThread5 extends Thread{
    @Override
    public void run() {
        System.out.println(this.getId() + ", " + this.getName());
    }
}
public class ThreadDemo16 {
    public static void main(String[] args) {
        MyThread5 t1 = new MyThread5();
        MyThread5 t2 = new MyThread5();
        t1.start();
        t2.start();
        System.out.println(t1.getId() + ", " + t1.getName());
        System.out.println(t2.getId() + ", " + t2.getName());
    }
}

如果是Runnable 或者 lambda的方式,this就无能为力了,此时this已经不再指向Thread对象了

就只能使用Thread.currentThread

public class ThreadDemo17 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            Thread t = Thread.currentThread();
            System.out.println(t.getName());
        });
        Thread t2 = new Thread(()->{
            Thread t = Thread.currentThread();
            System.out.println(t.getName());
        });

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

线程的状态/线程安全详见下一篇博客

你可能感兴趣的:(JavaEE初阶,运维,服务器,java-ee)