多线程详解（未完结）

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量345 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67689541/article/details/134615065
版权

文章目录

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，CSDN 首发！
📆入站时间： 🌴2022 年 07 月 13 日🌴
✉️ 是非不入松风耳，花落花开只读书。
💭推荐书籍：📚《Java编程思想》，📚《Java 核心技术卷》
💬参考在线编程网站：🌐牛客网🌐力扣
🍭 作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！🍭

一、线程简介

多任务：本质大脑在同一时间只做了同一件事情

多线程：公路的多条车道

普通方法：只有主线程一条执行路径

多线程：多条执行路径，主线程和子线程并行交替执行

1.1 进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

1.2 线程

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

1.3 多线程和多进程的区别

多进程：操作系统中同时运行的多个程序

多线程：在同一个进程中同时运行的多个任务

举个例子，多线程下载软件，可以同时运行多个线程，但是通过程序运行的结果发现，每一次结果都不一致。 因为多线程存在一个特性：随机性。造成的原因：CPU在瞬间不断切换去处理各个线程而导致的，可以理解成多个线程在抢CPU资源。

多线程并不能提高运行速度，但可以提高运行效率，让CPU的使用率更高。但是如果多线程有安全问题或出现频繁的上下文切换时，运算速度可能反而更低。

aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL0pvdXJXb24vaW1hZ2UvbWFzdGVyL0phdmElRTUlQjklQjYlRTUlOEYlOTElRTclQkMlOTYlRTclQTglOEItJUU1JTlGJUJBJUU3JUExJTgwJUU3JTlGJUE1JUU4JUFGJTg2LyVFNSVBNCU5QSVFNyVCQSVCRiVFNyVBOCU4Qi5

1.4 总结

  • 线程是独立的执行路径
  • main是主线程，是系统的入口，用于执行整个程序
  • 没有自己创建线程的情况下，后台也会有线程，如主线程、GC线程（垃圾回收）
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
  • 线程会带来额外的开销，如CPU调度时间和并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、继承实现

1、Thread class--------继承Thread类

2、Runnable接口-------实现Runnable接口

3、Callable接口---------实现Callable接口

2.1 继承Thread类

不建议使用：OOP单继承局限性

package space2.haobin;

/*
* 创建线程方式1:
*   自定义一个类继承Thread类
*   重写run()方法
*   调用start开启线程*/
public class ThreadTest extends Thread{

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码------"+i);
        }
    }

    public static void main(String[] args) {
        //main主线程

        //创建一个线程对象
        ThreadTest tt1 = new ThreadTest();

        //调用start()方法开启线程
        tt1.start();//若此处改为调用run()，即变成单线程，先走run()中的“我在看代码”

        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程------"+i);
        }
    }
}

线程不一定立即执行，CPU安排调度

交替执行

image-20230619105859517

例子：网图下载

Apache Commons IO 也就那么回事儿吧 - 掘金 (juejin.cn)

commons-io的下载和使用_唯有一片炙热的博客-CSDN博客

package space2.haobin;


import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/*
* 联系Thread,实现多线程同步下载图片
* */
public class ThreadTest2 extends Thread{

    private String url;//网络图片地址
    private String name;//保存的文件名

    /*构造器*/
    public ThreadTest2(String url,String name){
        this.url=url;
        this.name=name;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为:"+name);
    }

    /*主线程*/
    public static void main(String[] args) {
        ThreadTest2 t1 = new ThreadTest2("https://cdnjson.com/image/Tityr","dog.jpg");
        ThreadTest2 t2 = new ThreadTest2("https://cdnjson.com/image/TEsyr","dzq.jpg");
        ThreadTest2 t3 = new ThreadTest2("https://cdnjson.com/image/TEkdZ","boniu.jpg");

        t1.start();
        t2.start();
        t3.start();

    }
}

/*
* 下载器*/
class WebDownloader{
    /*下载方法*/
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常,downloader方法出现问题");
        }
    }
}

image-20230619120648701

2.2 实现Runnable接口 (推荐)

推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

  1. 定义MyRunnable类实现Runnable接口
  2. 实现run方法,编写线程执行体
  3. 创建线程对象，调用start方法启动线程
package space2.haobin;

/*创建线程方式2:
    实现Runnable接口
    重写run方法
    执行线程需要丢入Runnable接口实现类
    调用start方法
*/
public class ThreadTest3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码----"+i);
        }
    }

    public static void main(String[] args) {

        //创建Runnable接口的实现类对象
        ThreadTest3 tt3 = new ThreadTest3();

        //代理:
        //      创建线程对象，通过线程对象来开启我们的线程
        /*Thread t = new Thread(tt3);
        t.start();*/

        /*等价于*/
        new Thread(tt3).start();


        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习多线程----"+i);
        }


    }
}

案例：火车站买票问题

多个线程操作同一个对象

image-20230619195216458 
package space2.haobin;

/*
* 案例: 买火车票
* 多线程同时操作同一个对象
* */
public class ThreadTest04 implements Runnable{

    private int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"--->拿到第"+ticketNums--+"张票");
        }
    }


    public static void main(String[] args) {
        ThreadTest04 ticket = new ThreadTest04();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();
    }
}

并发问题

多线程操作同一个资源的情况下，线程不安全，数据紊乱。

  • 出现非法数字，0或-1
  • 出现相同的数字

案例：龟兔赛跑

package space2.haobin;


/*模拟龟兔赛跑*/
public class Race implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            /*模拟兔子休息*/
            if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

            if(gameOver(i)){
                break;//说明已经存在胜利者了，可以结束比赛了
            }
            System.out.println(Thread.currentThread().getName()+"---> 跑了"+i+"步");
        }
    }

    /*
    * 判断比赛是否结束*/
    private boolean gameOver(int steps){
        if(winner!=null){
            //说明已经存在胜利者了
            return true;
        }else{
            if(steps>=100){
                winner=Thread.currentThread().getName();
                System.out.println("Winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

2.3 实现Callable接口 (了解即可)

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

案例：下载网图

package space2.haobin02;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/*
 * 实现Callable接口,实现多线程同步下载图片
 * */
public class TestCallable implements Callable <Boolean>{

    private String url;//网络图片地址
    private String name;//保存的文件名

    /*构造器*/
    public TestCallable(String url,String name){
        this.url=url;
        this.name=name;
    }

    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为:"+name);
        return true;
    }

    /*主线程*/
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://cdnjson.com/image/Tityr","dog.jpg");
        TestCallable t2 = new TestCallable("https://cdnjson.com/image/TEsyr","dzq.jpg");
        TestCallable t3 = new TestCallable("https://cdnjson.com/image/TEkdZ","boniu.jpg");

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

        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        //获取返回值
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        //关闭服务
        ser.shutdown();
    }
}

/*
 * 下载器*/
class WebDownloader{
    /*下载方法*/
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常,downloader方法出现问题");
        }
    }
}

Runnable和Callable的区别:

Callable规定的方法是call(),Runnable规定的接口是run();

Callable的任务执行后可返回值,而Runnable的任务是不能有返回值的;

call方法可以抛出异常,run方法不可以

运行Callable任务可以拿到一个Future对象,表示异步计算的结果,它提供了检查是否计算完成的方法,以等待计算的完成,并检索计算的结果,通过Future对象可以了解任务执行情况,可以取消任务的执行,还可以获取执行结果

三、线程知识拓展

3.1 静态代理模式

  • 真实对象（目标对象）和代理对象都要实现同一个接口
  • 代理对象要代理真实角色
  • 好处：
    • 代理对象可以做许多真实对象做不到的事情
    • 真实对象可以专注做自己的事情

案例：结婚

package space2.haobin03;

/*静态代理模式*/
public class StaticProxy {

    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        /*相当于婚庆公司代理你结婚*/
        weddingCompany.HappyMarry();
        
        /*
        	如果不进行代理,则这样写:
        	You you = new You();
        	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 before(){
        System.out.println("婚前布置------");
    }
    /*模拟婚后*/
    private void after(){
        System.out.println("婚后洞房------");
    }
}
image-20230620152822043

3.2 简介Lamda表达式

好处：

  • 避免匿名内部类定义过多
  • 实质是函数式编程
  • 去掉多余的代码，留下核心代码逻辑
  • 简化代码

函数式接口：只包含唯一一个抽象方法的接口,我们可以通过Lambda表达式来创建该接口的对象。

image-20230620163027508

public interface Runnable{
    public abstract void run();
}

五种改进的变化

  • 直接实现类
  • 静态内部类
  • 局部内部类
  • 匿名内部类
  • Lambda表达式
package space2.haobin03;

public class TestLambda {

    //2.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("我喜欢Lambda2.");
        }
    }

    public static void main(String[] args) {

        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();


        //3.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("我喜欢Lambda3.");
            }
        }

        like = new Like3();
        like.lambda();

        //4.匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("我喜欢Lambda4.");
            }
        };
        like.lambda();

        //5.lambda简化
        like=()-> System.out.println("我喜欢Lambda5.");
        like.lambda();

    }
}

//定义一个函数式接口
interface ILike {
    void lambda();
}

//1.实现类
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("我喜欢Lambda.");
    }
}

Lambda表达式简化

参考文章

四、线程状态

4.0 线程的状态简介

image-20230620163646768

image-20230620163704483

image-20230620163357119

4.1 停止线程

  1. 使用退出标志，使线程正常退出，也就是当 run() 方法完成后线程中止。
  2. 使用 stop() 方法强行终止线程，但是不推荐使用这个方法，该方法已被弃用。
  3. 使用 interrupt 方法中断线程。

参考文章

image-20230620164713607

4.2

4.3

五、线程同步

4.1

4.2

4.3

六、线程通信问题

5.1

5.2

5.3

七、高级主题

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

[外链图片转存中…(img-muIWB1ub-1700896285751)]

[外链图片转存中…(img-L9bewrOX-1700896285751)]

4.1 停止线程

  1. 使用退出标志，使线程正常退出，也就是当 run() 方法完成后线程中止。
  2. 使用 stop() 方法强行终止线程，但是不推荐使用这个方法，该方法已被弃用。
  3. 使用 interrupt 方法中断线程。

参考文章

[外链图片转存中…(img-rj37EWtp-1700896285752)]

4.2

4.3

五、线程同步

4.1

4.2

4.3

六、线程通信问题

5.1

5.2

5.3

七、高级主题

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

程序员好冰
关注
Java多线程详解及示例
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
Python多线程详解
01-27
线程有5种状态，状态转换的过程如下图所示：多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一个列表里所有元素都是0，线程...
Java多线程详解
01-20
文章目录1、进程与线程2、创建多线程2.1、继承Thread类2.2、实现Runnable接口2.3、使用匿名内部类实现2.4、实现Runnable接口的好处2.5、使用Callable和Future创建线程3、线程的生命周期4、几种特殊线程4.1、join线程...
狂神说多线程详解.rar
05-06
《狂神说多线程详解》是一份深入探讨多线程技术的资源包，其中包含了对多线程编程的详尽解析。多线程是现代计算机编程中的一个重要概念，尤其在处理高性能计算、并发操作以及实时系统时，多线程技术显得尤为重要。它...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 614
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 254
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 569
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 552
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 444
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 700
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 296
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1091
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
Java - LeetCode面试经典150题(二)
心如冰清，天塌不惊
09-28 844
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 756
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 317
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 327
记忆中，两个指针合并即可。
Java中ResultSet接口的详细介绍
2301_77032029的博客
09-28 442
ResultSet接口是Java JDBC API中的一个核心接口，用于表示从数据库查询返回的结果集。它允许用户遍历查询结果，并从中提取数据。ResultSet接口代表从数据库查询返回的结果集，它提供了以下功能：遍历结果集：允许用户向前或向后移动指针，以便访问结果集中的每一行。
影院管理新思路：小徐的Spring Boot实践
2402_85758349的博客
09-28 972
Tomcat是非常受欢迎的服务器，因为它具有较好的扩展性，而且在运行的时候不需要太多的系统资源，拥有程序员所需要的收发邮件功能，还能够支持负载平衡，该程序能够不断的更新，程序员能够根据自己的需要增加新的功能。排错它是针对自己所知道的错误来做的事情并进行解决的。系统测试它是对做完一个系统进行最后的一项工作，因为我们在做系统的时候，在进行编码以后可以开始对软件进行测试，在测试当中我们可以找出这个软件的错误与缺陷，这样我们可以及时处理，不影响后期正常的使用，同时也方便我们在后期使用过程中出现的问题容易去找出。
力扣最热一百题——颜色分类
WenJGo的博客
09-28 1082
力扣最热一百题思维锻炼，两种解法两种写法，这次我不要脸。新手也能学会！！！
Delphi多线程详解：创建与应用实践
Delphi多线程详解深入探讨了在Delphi编程中实现多线程的各个方面。章节11首先定义了线程的基本概念，指出在Win32操作系统中，线程是表示进程中执行路径的对象，每个应用程序至少有一个主线程，但可以通过创建额外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值