多线程

最新推荐文章于 2022-09-26 13:27:47 发布

AKA豹猪

最新推荐文章于 2022-09-26 13:27:47 发布

阅读量224

点赞数

分类专栏： Java笔记文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_53244209/article/details/112673025

版权

一、线程与进程

1.1 线程与进程概念

进程

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行.一个进程最少有一个线程

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

1.2 线程调度

目的是为了更合理的利用CPU

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是
在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 补充

当一个进程里面一个线程都没有了，则这个进程关闭

二、同步与异步&并发与并行

2.1 同步与异步

同步:排队执行 , 效率低但是安全.
异步:同时执行 , 效率高但是数据不安全.

2.2 并发与并行

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

三、继承Thread

3.1 创建实例

创建一个继承Thread的类

public class MyThread extends Thread {
   
    //run 方法就是线程要执行的任务方法
    public void run(){
   
        //这里的代码就是新的执行路径
        //这个路径的出发方式，不是调用run方法，二手通过thread对象的start（）来启动任务
        for (int i = 0;i<10;i++){
   
            System.out.println("锄禾日防务"+i);
        }
    }
}

MyThread m = new MyThread();
        m.start();
        for (int i = 0;i<10;i++){
   
            System.out.println("锄禾日防务"+i);
        }

以上则是开启了两个线程，main方法是运行在主线程里面的

子线程任务里面所调用的方法都在子线程中进行

每个线程都拥有自己的栈空间，共有一份堆内

3.2 时序图

都在JVM里面发生
在这里插入图片描述

四、实现Runnable

4.1 使用方法

另一种实现多线程的方法

创建自定义类实现Runnable接口，并重写run方法；

用自定义类创建一个对象r；

用Thread类创建一个对象t，并将r作为t构造方法的参数；

public class MyRunnable implements Runnable{
   
    @Override
    public void run() {
   
        //线程的任务
        for (int i=0;i<10;i++){
   
            System.out.println("床前明月光"+i);
        }
    }
}

//实现Runnable
        //1,创建任务对象
        MyRunnable r = new MyRunnable();
        //2 创建一个线程，并为其分配一个任务
        Thread t = new Thread(r);
        //3 执行这个线程
        t.start();
        for (int i=0;i<10;i++){
   
            System.out.println("一是地上算"+i);
        }

4.2 实现Runnable与继承Thread

实现Runnable与继承Thread相比有如下优势

1，通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况；

2，可以避免单继承所带来的局限性（Java允许实现多个接口，但不允许继承多个父类）；

3，任务与线程是分离的，提高了程序的健壮性；

4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程；

Thread也有一定的好处
若是只需要调用一次，可以通过匿名内部类实现，代码更加简介

public class Demo2 {
   
    public static void main(String[] args) {
   
        new Thread(){
   
            public void run(){
   
                for (int i=0;i<10;i++){
   
                    System.out.println("一二三四五"+i);
                }
            }
        }.start();
        for (int i=0;i<10;i++){
   
            System.out.println("上山打老虎"+i);
        }
    }
}

五、Thread类

5.1 常用的构造方法

在这里插入图片描述

5.2 常用其他方法

在这里插入图片描述

表示优先级的字段

public final static int MAX_PRIORITY = 10;//最大优先级
public final static int MIN_PRIORITY = 1;//最小优先级
public final static int NORM_PRIORITY = 5;//默认优先级

在这里插入图片描述

面试中经常提出，线程怎么停止，这里不能用stop方法，因为stop方法不安全并且已经过时。
原理是：线程是一条单独的执行路径，有可能这条线程在做自己的事情，他的事情还没有做完，如果调用stop关掉,极有可能他在使用某些资源而没来得及释放(假设说如果正在进行IO操作，被调用stop，流没有被关闭，就会出现资源依然被占用的问题)，所以stop方法就被弃用

那么要怎么关闭掉线程呢？
（把变量作为标识结束）其实就是run方法结束，可以设置一个变量为1，run方法执行中观察此变量是否改变或者变为-1，如果变成-1直接return结束掉run方法，这样可以把资源释放后结束

所有的用户线程结束，程序才能结束。守护线程是为了守护用户线程，用户线程可以自动结束，所有用户线程结束后，守护线程便会像没有一样。

六、设置和获取线程名称

Thread有一个静态方法currentThread可以获得当前线程，调用getName/setName可以获得/设置线程名称

public class Demo3 {
   
    public static void main(String[] args) {
   
        //如何获取线程的名称
        System.out.println(Thread.currentThread().getName());
        new Thread(new MyRunnable(),"锄禾日当午").start();
    }
    static class MyRunnable implements Runnable{
   

        @Override
        public void run() {
   
            System.out.println(Thread.currentThread().getName());
        }
    }
}

在这里插入图片描述

七、线程休眠sleep

public class Demo4 {
   
    public static void main(String[] args) throws InterruptedException {
   
        //线程的休眠 sleep
        for (int i=0;i<10;i++){
   
            System.out.println(i);
            Thread.sleep(1000);
        }
    }
}

八、线程阻塞

也称其为耗时操作

九、线程的中断

过时的stop方法可以直接中断线程，但是如果线程来不及释放资源，会造成一部分垃圾无法回收；

这里采用添加中断标记的方法：调用interrupt方法，子线程执行时捕获中断异常，并在catch块中，添加处理释放资源的代码；

public class Demo5 {
   
    //线程阻塞
    //线程中断
    //一个线程四一个独立的执行路径，它是否应该结束，应该由其自身决定
    public static void main(String[] args) {
   
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i=1;i<5;i++){
   
            System.out.println(Thread.currentThread().getName()+i);
            try {
   
                Thread.sleep(1000);
            }catch (InterruptedException e){
   
                e.printStackTrace();
            }
        }
        //给线程t1添加中断标记
        t1.interrupt();
    }
    static class MyRunnable implements Runnable{
   

        @Override
        public void run() {
   
            for (int i=1;i<10;i++){
   
                System.out.println(Thread.currentThread().getName()+i);
                try {
   
                    Thread.sleep(1000);
                }catch (InterruptedException e){
   
                    //e.printStackTrace();
                    System.out.println("发现中断，让这个程序自杀");
                    return;
                }
            }
        }
    }
}

在这里插入图片描述

十、守护线程

10.1 概述

线程分为守护线程和用户线程；

用户线程：当一个进程不包含任何存活的用户线程时，进程结束；
守护线程：守护用户线程，当最后一个用户线程结束后，所有守护线程自动死亡；
直接创建的都是用户线程；

设置守护线程：线程对象.setDaemon(true)；

10.2 实例

public class Demo6 {
   
    //线程：分为守护线程和用户线程
    //用户线程：当一个进程不包含任何的存活的用户线程时，进行结束
    //守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡；
    public static void main(String[] args) {
   
        Thread t1 = new Thread(new MyRunnable());
        t1.setDaemon(true);
        t1.start()

最低0.47元/天解锁文章

AKA豹猪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程

一、线程与进程1.1 线程与进程概念进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行.一个进程最少有一个线程线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程1.2 线程调度目的是为了更合理的利用CPU分时调度所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。抢占式调度优先让优先级高的线程使用 CPU
复制链接

扫一扫