为什么要引入多线程?

为什么线程更轻?

线程和进程的关系

多线程的弊端

Thread类

用Thread类创建一个线程并启动它

用一段通过多线程体现并发执行的效果

start和run的区别

使用jdl自带的工具包jconsole查看当前java进程中的所有线程

调用栈

注意:

jave中创建线程的方法

1.继承Thread,重写run

2.实现Runnable接口

3.使用匿名内部类,继承Thread

4.使用匿名内部类,实现Runnable

5.使用Lambda表达式(最常用的)

Thread常见属性

前台线程和后台线程

isAlive()

isInterrupted()判断线程是否终止

interrupted

join()

sleep

当这个pcb回到就绪队列会被立即执行吗?

线程的状态

线程的几种状态:

多线程的意义

为什么要引入多线程?

多进程编程已经可以利用cpu的多核资源,解决并发编程了

但是进程太重了
创建一个进程,开销比较大
调度一个进程,开销也比较大
销毁一个进程,开销还是比较大

进程是操作系统资源分配的基本单位,
进程主要重在资源的开销和回收上

因此引入线程,线程也叫轻量进程
解决并发编程的前提下,让创建,销毁,调度的速度更快一些,提高程序执行效率

为什么线程更轻?

轻在把申请资源和释放资源的操作省下了.
举个例子
比如说现在有10个人要去饭店吃饭,有俩种方案
一种是10个人分别开10间包间吃饭
一种是10个人开1间包间吃饭
显然第一种开销更大,多花了许多的包间费
第二种开销更小,少花了许多包间费

线程和进程的关系

进程包含线程
一个进程包含1个或多个线程(不能1个都没有)
同一个进程中的线程之间,共用了进程的同一份资源(主要是内存(同1个进程中,线程1new的对象,线程2,3,4也可以用)和文件描述符(线程1打开的文件,线程2,3,4都可以直接使用))

线程是操作系统调度的基本单位
进程的调度相当于,每个进程只有1个线程这样的情况
如果1个线程有多个线程,每个线程都是独立在cpu上调度的

每个线程都有自己的执行逻辑.

一个核心上执行的是一个线程
如果一个进程有线程1和线程2
线程1可能在核心A上执行,
线程2可能在核心B上执行

一个线程也是通过PCB来描述的
1个进程里面可能对应一个PCB,也可能对应多个PCB,取决于这个进程中有多少个线程

PCB描述的特征里面,每个线程都有自己的调度属性(PCB的状态,上下文,优先级,记账信息)
各自记录各自的
但是同1个进程里面的PCB之间,pid是一样的,内存指针和文件描述符也是一样的

多线程的弊端

增加线程的数量,也不是可以一直提高速度
CPU核心数量有限,线程太多,不少的资源开销反而浪费在资源调度上面了

多线程的情况下,多个进程共享同一份资源空间,可能会发生冲突
线程1和线程2都想要同一份资源,此时就可能发生冲突,
可能会导致线程安全问题
在多进程中,就不会发生这种情况
如果一个线程抛异常,如果处理不好,可能就把整个线程带走了
这个进程中的其它线程也就挂了

Thread类

Thread类不需要import导入别的包,它是在java.long下面的,默认已经导入了

用Thread类创建一个线程并启动它

class MyThread extends Thread{
    @Override
    public void run() {
            System.out.println("hello world");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

这样做和直接在main方法中打印hello world有什么区别?

如果直接在main方法中打印hello world,我们java进程中主要就是一个线程.
(调用main方法中的线程)主线程
而通过start(),主线程调用start()创建了一个新的线程,新的线程调用run方法

用一段通过多线程体现并发执行的效果

class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            //为了方便观察,此处使用sleep休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hello thread");
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("hello main");
        }
    }
}

start和run的区别

start是真正创建了一个新的线程,线程是独立的执行流

run只是描述了线程干的活,并没有创建线程,如果直接在main方法中调用run,
此时没有创建新的线程,全是main一个人在干活

比如上面这个代码,把t.start,改成t.run结果截然不同

没有之前的main进程和t线程抢占式执行,因为此时只有main这1个进程.

使用jdl自带的工具包jconsole查看当前java进程中的所有线程

调用栈

注意:

new Thread对象操作,不创建线程(系统内核里的pcb)
调用start才创建pcb,才有真正的线程
PCB是一个数据结构,体现的是进程/线程是如何实现的,如何被描述出来的

jave中创建线程的方法

1.继承Thread,重写run

class MyThread extends Thread{
    @Override
    public void run() {
            System.out.println("hello world");
    }
}

2.实现Runnable接口

class MyRunnable implements Runnable{
    @Override
    //Runnable 的作用,是描述一个"要执行的任务",run方法描述的是任务要干的活
    public void run() {
        System.out.println("hello thread");
    }
}
public class ThreadDemo2{
    public static void main(String[] args){
        //描述了一个任务
        Runnable runnable = new MyRunnable();
        //把任务交给线程来执行
        Thread t = new Thread(runnable);
        t.start();
    }
}

这样做的目的是为了解耦合,让线程和线程要做的任务分离开
如果将来要改代码,不用多线程,使用多进程,线程池......此时代码改动较少

3.使用匿名内部类,继承Thread

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        };
        t.start();
    }
}

1.创建了一个Thread子类(子类没有名字)
2.创建了子类的实例,并让t指向这个子类

4.使用匿名内部类,实现Runnable

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        });
        t.start();
    }
}

此处创建了一个类,实现了Runnable接口,同时创建了一个实例,并把这个实例传入到Thread的构造方法.

5.使用Lambda表达式(最常用的)

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            System.out.println("hello world");
        });
        t.start();
    }
}

把任务用Lambda表示
把Lambda传给Thread构造方法

Thread常见构造方法

Thread(Runnab tarfet,String name)

Thread常见属性

前台线程和后台线程

前台线程:
手动创建的线程,默认是前台的,包括main默认也是前台线程
前台线程会阻止进程结束,前台线程的工作没做完,进程是结束不了的

后台线程:
其它的jvm自带的线程都是后台线程
可以使用setDaemon把线程设置成后台线程
后台线程不会阻止进程结束,后台线程的工作没做完,进程也是可以结束的

t本来是一个前台线程,如果t线程的任务不执行完,这个程序是不会结束的,会一直打印hello world
但是我们现在 把t线程设置成后台线程,t线程的任务还没执行完,程序也是可以结束的

isAlive()

在真正调用start之前,调用t.isAlive就是false
调用start之后,调用isAlive就是true

如果内核里线程把任务执行完了,此时线程销毁,pcb也随之释放,
但是Thread t这个对象不一定被释放
调用isAlive为false

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

isInterrupted()判断线程是否终止

线程终止:不是让线程立即终止,而是通知线程要终止了
线程是否终止,取决于线程的具体代码写法

此时线程可能立即终止
也可能等一会再终止
还可能忽略这个终止

1.使用标志位来控制线程是否要终止

public class ThreadDemo7 {
    private static boolean flag = true;
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while(flag){
                System.out.println("hello world");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        flag = false;
    }
}

2.使用Thread自带的标志位,来判断isInterrupted()

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

interrupted

上面这个代码的运行结果是这样的:

触发异常后,程序任然继续执行

使用interrput后,会执行如下三步操作

1.把线程内部的标志位boolean设置为true
2.如果线程在进行sleep,就会触发异常,把sleep唤醒
3.sleep在唤醒的时候,还会把刚才设置的标志位boolean,再设置为false(清空标志位)
这就导致了,当sleep异常被catch完了之后,循环继续执行

我们此时在打印异常后面,加一个break,结束,
就可以立即让线程t终止

我们还可以在catch后面加一些我们想要做的事
比如唤醒后,让线程等待1s,再打印个"彭于晏",才终止

所以interrupted清空标志位的目的是
为了让唤醒sleep之后,线程是立即终止
还是等一会再终止,还是忽略这个终止......
这个选择权交给我们自己

join()

join:等待一个线程

线程是一个随机调度的过程,
等待线程做的事就是,控制俩个线程结束的顺序

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

如果开始执行join的时候,t线程已经执行完毕,此时join不会阻塞,会立即返回

join的几个版本

sleep

休眠这个线程多少毫秒

让线程休眠,本质上就是让这个线程不去参与调度了(不去cpu上执行了)

pcb是使用链表的数据结构来组织的
但实际上,并不是一个简单的链表,而是一系列以链表为核心的数据结构

一旦线程进入了阻塞状态,对应的PCB就进入了阻塞队列了,此时线程暂时无法参与调度

比如调用sleep(1000),
对应的线程pcb就要再阻塞队列中待1s

当这个pcb回到就绪队列会被立即执行吗?

不一定,虽然是sleep(1000),但考虑到实际的调度开销,对应的线程无法在唤醒之后就被立即执行
它需要和其它在就绪队列的pcb一样,抢占cpu,实际时间间隔大于1s

线程的状态

状态是针对当前的线程调度描述的
线程是操作系统调度的基本单位,状态更适合线程

线程的几种状态:

1.NEW 创建了Thread对象,但还是没有调用start(内核还没有创建对应的pcb)

2.TERMINATED 表示内核中的pcb已经执行完毕(内核里的pcb已经销毁),但是Thread对象还在

3.RUNNABLE 可以运行的,包括正在cpu上执行的,和在就绪队列,随时可以去cpu上执行的

4.WAITING

5.TIMED_WAITING

6.BLOCKED

4,5,6都是阻塞(线程pcb在阻塞队列中),这几种状态是不同原因的阻塞

public class ThreadDemo10 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 100_0000; i++) {
               //此处这个循环什么都不做
            }
        });
        //启动之前获取一下t的状态,也就是NEW状态
        System.out.println("start之前 "+t.getState());
        t.start();
        System.out.println("t线程正在执行中 "+t.getState());
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t结束之后 "+t.getState());
    }
}

我们再在上面这个代码稍加改动

public class ThreadDemo10 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            for (int i = 0; i < 100_0000; i++) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //启动之前获取一下t的状态,也就是NEW状态
        System.out.println("start之前 "+t.getState());
        t.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("t线程正在执行中 "+t.getState());
        }
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t结束之后 "+t.getState());
    }
}

我们可以看到打印的t线程正在执行中的状态有,RUNNABLE,也有TIME_WAITING,
当t线程没有执行到sleep(10)的时候,就是RUNNABLE,比如正在执行for循环里面(int i = 0;i<100_0000;i++)这些
当t线程执行到sleep(10),t线程发生阻塞,此时再获取t线程的状态就是TIME_WAITING

多线程的意义

程序分成
CPU密集,包含大量的加减乘除等运算,
IO密集型,涉及到大量的读写操作,比如读写文件,读写控制台,读写网络......

写个代码感受一下多线程的意义

假设当前有俩个变量a,b,需要把俩个变量a,b各自自增100亿次(典型的CPU密集型场景),
串行执行:可以一个线程,先针对a自增,然后再针对b自增
并发执行:还可以俩个线程,线程1对a进行自增,线程2对b进行自增

1.串行执行

public class ThreadDemo11 {
    public static void main(String[] args) {
        serial();
    }
    //串行执行
    public static void serial(){
        //为了衡量代码的执行速度,加上计时操作
        //currentTimeMillis 获取当前系统的 ms 级时间戳
        long beg = System.currentTimeMillis();
        long a = 0;
        for(long i = 0;i < 100_0000_0000L;i++){
            a++;
        }
        long b = 0;
        for(long i = 0;i < 100_0000_0000L;i++){
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println("串行耗时: "+(end - beg)+"ms");
    }
}

2.并发执行

public class ThreadDemo11 {
    public static void main(String[] args) {
        concurrency();
    }
    //多线程执行
    public static void concurrency(){
        //使用俩个线程分别完成自增
        Thread t1 = new Thread(()->{
            long a = 0;
            for(long i = 0;i < 100_0000_0000L;i++){
                a++;
            }
        });
        Thread t2 = new Thread(()->{
            long b = 0;
            for(long i = 0;i < 100_0000_0000L;i++){
                b++;
            }
        });
        //开始计时
        long beg = System.currentTimeMillis();
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        //结束计时
        long end = System.currentTimeMillis();
        System.out.println("并发执行时间: "+(end - beg) +"ms");
    }
}