多线程 ＞ 基础篇（一）

已于 2022-03-07 15:59:07 修改
阅读量1.1k 收藏 1
点赞数
文章标签： java 多线程 lambda
于 2022-02-24 10:45:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shen_Junxiao/article/details/123103831
版权

线程

初识线程

执行顺序

程序.进程.线程

  • 程序 是 指令和数据的有序集合 ，是一个静态的概念。
  • 进程 是 执行程序的依次执行过程 ，是一个动态的概念。是系统资源分配的单位。
  • 一个进程中可以包含若干个 线程 ，一个进程中至少有一个线程。线程是CPU调度和执行的单位。

线程创建

创建线程四种方法

  1. 继承Thread类，重写run()方法
  2. 实现Runnable()接口，重写run()方法
  3. 实现Callabl()接口，重写call()方法
  4. 线程池

1. 继承Thread类

不推荐使用，避免OOP单继承的局限性

自定义线程类继承 ‘Thread’ 类
重写 ‘run()’ 方法，编写线程执行体
创建线程对象，调用 ‘start()’ 方法启动线程
线程不一定立即执行，CPU安排调度

/**
 * 线程实现方式一：
 * 1. 继承Thread类
 * 2. 重写run方法
 * 3. 调用start开启线程
 *
 * 不推荐使用，避免OOP单继承的局限性
 */
public class ThreadExtends extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我喝了" + (i + 1) + "口水！");
        }
    }

    public static void main(String[] args) {
        ThreadExtends threadExtends = new ThreadExtends();
        
     	// 只有 主线程main 一条执行路径  
        // run = 插队
        // threadExtends.run();

        // 多条执行路径
        // start = 开辟新的执行路径
        // 主线程main和子线程run交替执行
        threadExtends.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("第吃了" + (i + 1) + "口饭！");
        }
    }
}

/**
 * 继承Thread类实现多线程下载图片
 */
public class ThreadExtendsDemo extends Thread {

    public String url;
    public String name;

    public ThreadExtendsDemo(String url, String name) {
        this.url = url;
        this.name = name;
    }

    /**
     * 下载图片线程的执行体
     */
    @Override
    public void run() {
        // 重写run方法
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoad(url, name);
        System.out.println("下载了文件名为：" + name);
    }

    public static void main(String[] args) {
        ThreadExtendsDemo t1 = new ThreadExtendsDemo("http://cms-bucket.ws.126.net/2019/12/19/cf143f1465dc403c86cb7dc5e86a2c90.png", "WY_logo.jpg");
        ThreadExtendsDemo t2 = new ThreadExtendsDemo("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png", "baidu_log.jpg");
        ThreadExtendsDemo t3 = new ThreadExtendsDemo("https://docs.alibabagroup.com/assets2/images/cn/global/logo_header.png", "alibaba-log.jpg");

        /**
         * 线程不一定立即执行，CPU安排调度
         */
        t1.start();
        t2.start();
        t3.start();
    }

}

// 下载器
class WebDownloader {
    // 下载方法
    public void downLoad(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downLoad方法下载失败！");
        }
    }
}

2. 实现Runnable()接口

推荐使用Runnable对象，因为Java单继承的局限性

自定义线程类实现 Runnable 接口
实现 run() 方法,编写线程执行体
创建线程对象
丢入 Runnable 接口实现类，调用 start 开启线程（静态代理）

/**
 * 线程实现方式二：
 * 1. 实现Runnable接口
 * 2. 重写run方法
 * 3. 执行线程需要丢入Runnable接口实现类，调用start开启线程
 *
 * 推荐使用，避免了单继承的局限性，方便了同一个对象被多个线程使用
 */
public class ThreadRunnable implements Runnable {
    
  	@Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我喝了" + (i + 1) + "口水！");
        }
    }

    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        ThreadRunnable threadRunnable = new ThreadRunnable();
        // 创建线程对象，通过线程对象开启我们的线程。
        // 静态代理
        new Thread(threadRunnable).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("第吃了" + (i + 1) + "口饭！");
        }
    }
}

/**
 * 多个线程操作同一个对象
 * 买火车票
 */
public class ThreadRunnableTicketDemo implements Runnable {

    // 票数
    private int ticketNum = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }

            // 模拟延时：提高问题的发生性
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + " --> 拿到了第" + ticketNum-- + "张票");
        }
    }

    public static void main(String[] args) {
        ThreadRunnableTicketDemo ticketThread = new ThreadRunnableTicketDemo();
        new Thread(ticketThread, "张三").start();
        new Thread(ticketThread, "李四").start();
        new Thread(ticketThread, "黄牛党").start();
        // 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。
    }
}

3. 实现Callable()接口

  1. 实现 Callable 接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建线程目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(3);
  5. 提交执行：Future result1 = ser.submit(线程目标对象);
  6. 获取结果：boolean r1 = result1.get()
  7. 关闭服务：ser.shutdownNow();

好处：

可以定义返回值
可以抛出异常

/**
 * 线程实现方式三：
 * 1. 实现Callable接口
 * 2. 重写call方法
 * 3. 创建目标对象
 * 4. 创建执行服务 ExecutorService service = Executors.newFixedThreadPool(3);
 * 5. 提交执行 Future<Boolean> submit1 = service.submit(t1);
 * 6. 获取执行结果 Boolean aBoolean1 = submit1.get();
 * 7. 关闭服务 service.shutdownNow();
 * <p>
 * 好处：
 * 1. 可以定义返回值
 * 2. 可以抛出异常
 */
public class ThreadCallable implements Callable<Boolean> {

    public String url;
    public String name;

    public ThreadCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        // 重写run方法
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoad(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) {
        ThreadCallable t1 = new ThreadCallable("http://cms-bucket.ws.126.net/2019/12/19/cf143f1465dc403c86cb7dc5e86a2c90.png", "WY_logo.jpg");
        ThreadCallable t2 = new ThreadCallable("https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png", "baidu_log.jpg");
        ThreadCallable t3 = new ThreadCallable("https://docs.alibabagroup.com/assets2/images/cn/global/logo_header.png", "alibaba-log.jpg");

        // 创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(3);

        // 提交执行
        Future<Boolean> submit1 = service.submit(t1);
        Future<Boolean> submit2 = service.submit(t2);
        Future<Boolean> submit3 = service.submit(t3);

        try {
            // 获取执行结果
            Boolean aBoolean1 = submit1.get();
            Boolean aBoolean2 = submit2.get();
            Boolean aBoolean3 = submit3.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭服务
            service.shutdownNow();
        }
    }
}

// 下载器
class WebDownloader {
    // 下载方法
    public void downLoad(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downLoad方法下载失败！");
        }
    }
}

4. 线程池（JUC）

线程池提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提交了响应速度。

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
    可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
  • 好处：
    * 提高响应速度(减少了创建新线程的时间)
    * 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
    * 便于线程管理…
    • corePoolSize：核心池的大小
    • maximumPoolSize：最大线程数
    • keepAliveTime:：线程没有任务时最多保持多长时间后会终止
  1. JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
  2. ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
  3. void execute(Runnable command) ：执行任务/命令,没有返回值，一般用来执Runnable
  4. Future submit(Callable task)：执行任务,有返回值，一般用来执行Callable
  5. void shutdown() ：关闭连接池
  6. Executors: 工具类、线程池的工厂类，用于创建并返回不同类型的线程池
/**
 * 测试线程池
 * service.execute(threadPool);
 * 执行任务/命令，没有返回值，一般用来执行Runnable
 */
public class ThreadPool {

    public static void main(String[] args) {

        // 1. 创建线程池服务
        // newFixedThreadPool(线程池大小)
        ExecutorService service = Executors.newFixedThreadPool(10);

        ThreadRunnable threadRunnable = new ThreadRunnable();

        // 2. 执行
        service.execute(threadRunnable);
        service.execute(threadRunnable);
        service.execute(threadRunnable);
        service.execute(threadRunnable);
        service.execute(threadRunnable);

        //3. 关闭服务
        service.shutdown();
    }
}

class ThreadRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

/**
 * 测试线程池
 * service.submit(threadCallable);
 * 执行任务，有返回值，一般用来执行Callable
 */
public class ThreadPool2 {

    public static void main(String[] args) {

        // 1. 创建线程池服务
        // newFixedThreadPool(线程池大小)
        ExecutorService service = Executors.newFixedThreadPool(10);

        ThreadCallable threadCallable = new ThreadCallable();

        // 2. 提交执行
        Future<Boolean> submit1 = service.submit(threadCallable);
        Future<Boolean> submit2 = service.submit(threadCallable);
        Future<Boolean> submit3 = service.submit(threadCallable);
        Future<Boolean> submit4 = service.submit(threadCallable);
        Future<Boolean> submit5 = service.submit(threadCallable);

        //3. 关闭服务
        service.shutdown();
    }

}

class ThreadCallable implements Callable<Boolean> {

    @Override
    public Boolean call() {
        System.out.println(Thread.currentThread().getName());
        return true;
    }
}

静态代理

举例：婚庆公司代理结婚对象，处理结婚事宜。
在这里插入图片描述

/**
 * 静态代理
 *
 * 真实对象和代理对象都要实现同一个接口
 * 代理对象必须要代理真实对象
 *
 * 好处：
 * 代理对象可以做很多真实对象做不了的事情
 * 真实对象专注做自己的事情
 */
public class StaticProxy {

    public static void main(String[] args) {
        // 你要结婚
        You you = new You();
        // 婚庆公司帮助你结婚
        /*WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.happyMarry();*/

        // 对比： Thread就是个代理对象
        new Thread(() -> System.out.println("我爱你！")).start();
        new WeddingCompany(you).happyMarry();
    }

}

/**
 * 结婚接口
 */
interface Marry {
    void happyMarry();
}

/**
 * 真实结婚对象,你去结婚
 */
class You implements Marry {

    @Override
    public void happyMarry() {
        System.out.println("张三结婚了，很开心！");
    }
}

/**
 * 代理结婚对象，帮助你结婚
 */
class WeddingCompany implements Marry {

    // 代理谁 --> 代理真实对象
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {

        before();
        // 这就是真实对象
        this.target.happyMarry();
        after();
    }

    private void after() {
        System.out.println("结婚之后，收尾款！");
    }

    private void before() {
        System.out.println("结婚之前，布置现场！");
    }
}

总结
真实对象和代理对象都要实现一个接口
代理对象要代理真实角色
好处
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事

汇总：线程结合lamda使用其实也是静态代理

new Thread(() -> System.out.println("我爱你！")).start();

Lamda

Lamda来由

先看Lamda解决了什么问题：

  • 避免匿名内部类定义过多
  • 其实质属于函数式编程的概念
  • 去掉了一堆没有意义的代码,只留下核心逻辑

学习Lamde首先要提到 函数式接口（Functional Interface） ，这是学习Java8 lamda表达式的关键

函数式接口

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

# 例如Runnable接口，就是一个函数式接口
public interface Runnable{
    public abstract void run();
}

Lamda表达式推导

public class LambdaWithNotParameter {

    // 3. 静态内部类
    static class StaticInnerClasses implements ILike {
        @Override
        public void lambda() {
            System.out.println("我是静态内部类");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        like = new StaticInnerClasses();
        like.lambda();
        // 4. 局部内部类
        class LocalInnerClasses implements ILike {
            @Override
            public void lambda() {
                System.out.println("我是局部内部类");
            }
        }
        like = new LocalInnerClasses();
        like.lambda();
        // 5. 匿名内部类，没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("我是匿名内部类");
            }
        };
        like.lambda();
        // 6. Lambda简化
        like = () -> {
            System.out.println("我是Lambda");
        };
        like.lambda();
    }
}

/**
 * 1. 定义函数式接口
 * 接口中只有一个方法的接口
 */
interface ILike {
    void lambda();
}

/**
 * 2. 实现类
 */
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("我是内部类");
    }
}

总结

学习完以上内容，我学会了：

  1. 创建线程的四种方式，分别是继承Thread类，实现Runnable接口，实现Callable，线程池创建。
  2. 体会到线程的静态代理模式。
  3. 懂了Lambda表达式。
Shen_Junxiao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1.多线程基础
624回锅肉的博客
03-10 145
123
多线程基础
清杉夫人
08-02 643
文章目录1.多线程的开启使用匿名内部类完成多线程的开启使用匿名内部类完成实现runnable接口2.获取名字和设置名字通过getName获取名字（在没有将线程命名时，线程自动编号）通过setName方法设置名字3.currentThread（获取当前执行的线程的对象）4.Thread.sleep(休眠线程)5.（setDaemon）守护线程6.jion（）（加入线程）7.（synchronized...
Java基础多线程上篇
孤夜的博客
04-25 4836
一.线程相关概念 1.什么是程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。简单的说就是我们写的代码（数据结构+算法）。 备注:软件不等于程序,软件可以简单理解为由相关开发文档和程序组成 2.什么是进程 ① 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。 ② 进程是程序的一次执行过程,或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程。 ③ 进程
Java Web基础篇之Java多线程
聚沙成塔
05-08 5556
1、多线程与进程 1.1、是什么? 线程有时被称为轻量进程(Lightweight Process，LWP），是程序执行流的最小单元，进程与线程区别如下：一个进程至少有一个线程.。 1.2、扩展： 进程与线程区别，线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每...
一篇文章，搞懂异步和多线程的区别
程序新视界
02-15 5018
最近在研究Spring Boot中的异步处理，发现涉及到异步和多线程的很多知识点，就先写几篇关于异步与多线程的文章，带大一起回顾或学习一下相关的知识点。下面开始正文内容： 前言 在本文中，我们通过一些通俗易懂的方式来解释异步编程和多线程编程，然后再介绍一下它们之间的区别。 什么是异步编程 首先来看一下异步模型。在异步模型中，允许同一时间发生（处理）多个事件。程序调用一个耗时较长的功能（方法）时，它并不会阻塞程序的执行流程，程序会继续往下执行。当功能执行完毕时，程序能够获得执行完毕的消息或能够访问到执行的结果
Java多线程之基础篇(一).docx
04-16
Java多线程是Java语言中的一个重要特性，它允许程序同时执行多个不同的任务，从而提高程序的效率和响应性。在操作系统层面，实现并发最常见的方式是通过进程和线程。进程是具有独立内存空间的执行单元，而线程是进程...
Java第九章多线程程序设计基础篇.ppt
11-13
Java 多线程程序设计基础 多线程程序设计是 Java 语言的一个重要特性，允许程序同时执行多个任务，从而提高程序的效率和响应速度。本章将详细介绍 Java 多线程程序设计的基础知识。 §9.1 线程的概念 在 Java 中...
Java多线程之基础篇(二).docx
04-16
Java 多线程是Java语言中的一个重要特性，它允许程序同时执行多个任务，从而提高了程序的效率和响应性。在Java中，多线程的实现主要依赖于线程的并发执行，而不是操作系统级别的进程切换。虽然进程之间的隔离保护了...
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3231
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 354
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1230
浅析synchronized锁升级的原理与实现
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 783
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7296
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
深度解读并发安全集合的原理及源码
DougLiang的博客
09-01 1388
本节主要介绍J.U.C包中的几种并发安全集合：ConcurrentHashMap,ConcurrentLinkedQueue,和ConcurrentLinkedDeque。所谓并发安全集合，相对于普通集合来说，能够保证在多线程环境下向集合中添加数据时的线程安全性。主要讲ConcurrentHashMap在实现线程安全性方面对性能和安全性的合理平衡。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 984
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
央顺科技官方博客
08-31 1379
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1699
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
【计算机毕业设计】高校课堂教学管理系统
最新发布
weixin_47772925的博客
09-04 1052
2.1Java是由SUN公司推出，该公司于2010年被oracle公司收购。Java本是印度尼西亚的一个叫做爪洼岛的英文名称，也因此得来java是一杯正冒着热气咖啡的标识。Java语言在移动互联网的大背景下具备了显著的优势和广阔的前景，它是面向对象的，分布式的，动态的，具有平台无关性、安全性、健壮性。Java语言的基本语句语法和C++一样，但是它面向对象的技术更加彻底，因为Java要求将所有的内容都必须封装成类，把类作为程序的基本单位。由于不允许类外有变量、方法。
Java多线程基础解析：从入门到理解核心概念
"java多线程基础篇讲解" Java多线程是编程领域的重要概念，尤其在现代计算系统中，多线程模型对于充分利用系统资源、提高应用程序性能具有至关重要的作用。本文将对Java多线程的基础知识进行讲解，适合初学者入门。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值