温习-多线程

我是小配菜

已于 2022-11-02 14:53:42 修改

阅读量355

点赞数 2

分类专栏： java 文章标签： java

于 2022-10-18 18:01:40 首次发布

本文链接：https://blog.csdn.net/weixin_51966599/article/details/127320500

版权

java 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

文章目录

多线程的基本概念

在讲多线程之前，我们来了解下cpu，大家都知道关于进程和线程的操作都离不开我们的cpu，可以说我们的线程是运行在cpu之上

什么是cpu

CPU的中文名称是中央处理器，是进行逻辑运算用的
主要由运算器、控制器、寄存器三部分组成，
从字面意思看就是运算就是起着运算的作用，
控制器就是负责发出cpu每条指令所需要的信息，
寄存器就是保存运算或者指令的一些临时文件

什么是进程

在这里插入图片描述
进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配。每个进程都有相应的线程，在执行程序时，实际上是执行相应的一系列线程。
总结：进程是资源分配最小单位，线程是程序执行的最小单位

从我们生活上来说，进程就是我们使用电脑打开一个程序在这过程中cpu会从硬盘中读取一段程序到内存中就是进程，你打开QQ应用那么cpu就会进行调用硬盘中qq.exe然后进行执行，执行的一些临时文件会保存在内存中，
线程是程序执行的最小单位，在一个进程中可以有多个不同的线程

为什么在进程中还需要线程呢？

同一个应用程序中（进程），更好并行处理
在这里插入图片描述

为什么需要使用到多线程

目的就是为了提高程序开发的效率，
比如：现在一个项目只有小王一个程序员，需要开发功能模块会员模块、支付模块、订单模块。需要的开发周期是30天，但是这个项目比较急10天内要搞定，这个时候我们就可以找小郑、小朱来负责其他两个模块的开发这样就可以大大提高了开发的效率，如果小郑在开发中出现了bug也不会影响其他两人的进度了

并行/串行区别
串行也就是单线程执行代码执行效率非常低，代码从上向下执行；
并行就是多个线程并行一起执行，效率比较高。

使用多线程一定提高效率吗？

多线程执行需要同时执行

不一定，需要了解cpu调度的算法
就是先把前一个任务的 CPU 上下文（也就是 CPU 寄存器和程序计数器）保存起来，然后加载新任务的上下文到这些寄存器和程序计数器，最后再跳转到程序计数器所指的新位置，运行新任务

如果生产环境中开启几百个或者上千个线程，而我们的服务器核数8核、16核、32核，这么多线程都会在我们这些cpu上做上下文切换

同步与异步的区别

同步概念：就是代码从上向下执行。
异步的概念：单独分支执行相互之间没有任何影响

CPU调度时间片

1.单核的cpu上每次只能够执行一次线程，如果在单核的cpu上开启了多线程，则会发生对每个线程轮流执行。
2.Cpu每次单个计算的时间成为一个cpu时间片，实际只有几十毫秒人为感觉好像是
在多线程。
3.对于线程来说，存在等待cpu调度的时候该线程的状态是为就绪状态，如果被cpu调度则该线程的状态为运行状态
4.当cpu转让执行其他的线程时，则该线程有变为就绪状态。

如果在单核的cpu之上开启了多线程，底层执行并不是真正意义上的多线程。
利用多核多线程性能

CPU调度算法原理

1.先来先服务缺点如果最先来执行的线程是CPU密集型这样话可能会一直无法继续执行其他的线程。
2.最短作业法谁的计算时间短，谁先来执行。
3.优先级调度算法根据重要性将进程分成4个优先级
优先级4 进程D负责画面----
优先级3 进程B和进程C接受用户的指令重要
优先级2 后台处理器次要
优先级1

多线程的应用场景

一般在我们开发中使用到多线程地方还是蛮多的就看你这么发挥了

我列下那些场景下会使用到多线程
1.客户端（移动App端/）开发；
2.异步发送短信/发送邮件
3.将执行比较耗时的代码改用多线程异步执行；可以提高接口的响应速度
4.异步写入日志日志框架底层
5.多线程下载
–

多线程的创建方式

背过吧八股文的都知道有那三中方式，其实除了那三中方式外还有其他方式可以创建多线程

继承Thread类创建线程
实现Runnable接口创建线程
使用匿名内部类的形式创建线程
使用lambda表达式创建线程
使用Callable和Future创建线程
使用线程池例如用Executor框架
spring @Async异步注解结合线程池

Thread类创建线程

public class ThreadDemo01  extends Thread{
    /**
     * 线程执行的代码在run方法中
     */
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"<run>");
        try
        {
            // 当前子线程阻塞3秒时间
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("阻塞完毕");
    }

    public static void main(String[] args) { // main 主线程
        System.out.println("获取当前主线程"+Thread.currentThread().getName());
        // 启动线程 调用start() 方法不是run()方法
        new ThreadDemo01().start(); // start 就绪状态 -- 等待cpu调用
        new ThreadDemo01().start();
        System.out.println("主线程执行完毕!");
    }
}

实现Runnable接口创建线程

public class ThreadDemo02 implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName() + ",我是子线程");
        // 
    }

    public static void main(String[] args) {
        new Thread(new ThreadDemo02()).start();
    }
}

使用匿名内部类的形式创建线程

public class ThreadDemo02 {
    public static void main(String[] args) {
      // 使用匿名内部类的形式创建线程 java8的新特性
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ",>我是子线程<");
            }
        }).start();
    }
}

使用lambda表示创建线程

public class ThreadDemo02 {
    public static void main(String[] args) {
    // 使用lambda表示创建线程
 new Thread(()->{
            System.out.println(Thread.currentThread().getName() + ",>我是子线程<");
        }).start();
    }
}

使用Callable和Future创建线程

public class ThreadCallable  implements Callable<Integer> {
/*  从Java 5开始，Java提供了Callable接口，该接口是Runnable接口的增强版，		Callable接口提供了一个call()方法，可以看作是线程的执行体
   主要 call()方法可以有返回值。
    call()方法可以声明抛出异常*/
    @Override
    public Integer call() throws Exception {
        // 默认代码执行非常耗时!!
        System.out.println(Thread.currentThread().getName() + ",执行计算操作");
        return 1;
    }

    public static void main(String[] args) {
        ThreadCallable threadCallable = new ThreadCallable();
        FutureTask<Integer> integerFutureTask = new FutureTask<>(threadCallable);
        new Thread(integerFutureTask).start();
        // 我们的主线程要等待我们子线程给我的返回结果
        Integer result = null;
        try {
            result = integerFutureTask.get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
        System.out.println("结果"+result);
    }


}

使用线程池例如用Executors框架

public class ThreadExectors {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子线程");
            }
        });
    }
}

spring @Async异步注解

@Async 底层基于aop+自定义注解实现

@Component
@Slf4j
public class OrderManage {
    @Async
    public void asyncLog() {
        try {
            Thread.sleep(3000);
            log.info("<2>");
        } catch (Exception e) {

        }

    }
}

@RequestMapping("/addOrder")
public String addOrder() {
    log.info("<1>");
    orderManage.asyncLog();
    log.info("<3>");
    return "3";
}

多线程线程安全安全问题

思考下什么情况下会发生线程安全的问题…

当多线程同时对一个全局变量进行写的操作时，可能会受到其他线程的干扰，就会发生线程安全问题

public class ThreadCount implements Runnable {
    private static Integer count = 100;

    @Override
    public void run() {
        while (count > 1) {
            cal();
        }
    }

    private  void cal() {
        try {
            Thread.sleep(20);
        } catch (Exception e) {

        }
        count--;
        System.out.println(Thread.currentThread().getName() + "," + count);
    }


    public static void main(String[] args) {
        ThreadCount threadCount = new ThreadCount();
        Thread thread1 = new Thread(threadCount);
        Thread thread2 = new Thread(threadCount);
        thread1.start();
        thread2.start();
    }
}