Chp21-线程

最新推荐文章于 2024-09-30 20:09:33 发布
最新推荐文章于 2024-09-30 20:09:33 发布
阅读量1k 收藏 29
点赞数 8
分类专栏： JavaEE 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62214280/article/details/140218156
版权

Chp21-线程

进程的概念

操作系统(OS)中并发(同时)执行的多个程序任务

进程的特点

宏观并行, 微观串行

CPU会将一个时间段划分为若干个时间片, 程序想要执行必须拥有时间片, 且一个时间片只能被一个程序拥有, 时间片之间交替执行, 则程序之间也是如此. 当时间片的划分足够细小,交替频率足够快,就会形成宏观并行的假象, 实际上仍然是串行状态

线程的概念

进程中并发执行的多个任务

线程的特点

宏观并行, 微观串行

一个时间片只能被一个程序拥有, 一个程序无法同时执行多个线程, 时间片之间是交替, 线程任务的执行自然也是交替的

多线程的概念

只有多线程,没有多进程

“进程”: 正在进行中的程序, 只有拥有时间片的程序才是进程

“线程”: 不管是否在执行, 只要被创建出来就都是线程

线程的组成

线程执行的基本支持

  1. 时间片: 由CPU调度分配
  2. 数据: 每个线程任务都对应一个功能, 数据是功能执行的基本支持
  3. 代码: 书写数据的操作逻辑+控制线程执行

线程的创建

Thread : 线程类,每个Thread对象都是一个单独的线程任务

  1. 书写子类继承Thread, 重写run方法书写任务内容, 创建子类对象

    public class MyThread extends Thread {

    public void run() {
        //输出1-100
        for (int i = 1; i <=100; i++) {
            System.out.println(i);
        }
    }
}

    import com.by.thread.MyThread;

public class Test1 {
    public static void main(String[] args) {
        //创建线程对象1
        Thread t1 = new MyThread();
        //创建线程对象2
        Thread t2 = new MyThread();
        //开启线程
        t1.start();
        t2.start();
    }
}

弊端:

  1. 会将线程类与线程任务内容绑定, 不有利于后续的使用和维护
  2. 破坏线程类的单一职责

  1. 直接创建Thread对象, 在构造中传入Runnable线程任务

    1. 创建Runnable接口的实现类, 重写run()书写任务内容
    2. 在Thread构造中传入实现类对象
    /**
 * 线程任务的实现类- 适用于任务内容会多次执行时
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //输出1-100
        for (int i = 1; i <=100; i++) {
            System.out.println("输出-> "+i);
        }
    }
}

    import com.by.dao.impl.MyRunnable;

public class Test2 {
    public static void main(String[] args) {
        //创建线程对象, 传入任务内容
        Thread t1=new Thread(new MyRunnable());
        //如果线程任务只会被当前一个线程对象使用, 可以直接使用匿名内部类创建实现类对象
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //遍历101-200
                for (int i = 101; i <= 200 ; i++) {
                    System.out.println("t2>> "+i);
                }
            }
        });
        //lambda简化匿名内部类
        Thread t3 = new Thread(()->{
            //遍历201-300
            for (int i = 201; i <= 300 ; i++) {
                System.out.println("t3:::: "+i);
            }
        });

        //开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

使用

  1. 通过线程对象.start()开启线程
  2. 执行: 当开启多个线程后, 线程之间开始争抢时间片, 拿到时间片的线程才能执行自身内容, 当时间片被其他线程抢走,则暂停执行再次争抢时间片, 直至线程任务内容执行结束, 线程才会停止运行
  3. run()来自Runnable接口, 表示线程任务内容, 当线程拿到时间片后, 会自动执行该方法
  4. 主函数也称为主线程, 是JVM中默认存在的线程, 也一定是第一个拿到时间片的线程
  5. 当开启多个线程之后, JVM执行结束的标志就会从主线程执行结束转换为所有线程执行结束

线程状态

基础状态

线程的生命周期

  • 只有就绪状态和运行状态之间可以相互切换

等待状态

  1. sleep(): 使当前线程休眠指定时长, 在休眠期间会释放自身时间片, 进入有限期等待状态,直到休眠结束才能回到就绪状态

    静态方法: Thread.sleep(毫秒数);//1秒 = 1000毫秒
    • 该方法需要处理非运行时异常, run()不支持上抛异常, 必须try-catch处理
    • 常用于定时任务
    package com.by.test;

public class Test3 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //使当前线程休眠3秒钟
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    System.out.println("休眠异常!");
                }
                for (int i = 1; i <= 100 ; i++) {
                    System.out.println("t1>> "+i);
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 101; i <= 200 ; i++) {
                System.out.println("t2: "+i);
            }
        });
        //开启线程
        t1.start();
        t2.start();

    }
}

  2. join(): 使调用者线程早于当前线程执行, 只有当调用者线程执行结束进入死亡状态, 当前线程才能进入就绪状态

    线程对象.join()
    • 当前线程进入的是无限期等待状态
    • 需要处理非运行时异常, run()无法上抛异常, 必须try-catch处理
    • 无法影响无关线程
    • 常用于调整线程执行优先级
    package com.by.test;

public class Test4 {
    public static void main(String[] args) {
        //t2->t1-->t3
        Thread t2 = new Thread(()->{
            for (int i = 101; i <= 200 ; i++) {
                System.out.println("t2: "+i);
            }
        });

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //使t2线程在当前线程之前执行
                    t2.join();
                } catch (InterruptedException e) {
                    System.out.println("join异常!");
                }
                for (int i = 1; i <= 100 ; i++) {
                    System.out.println("t1>> "+i);
                }
            }
        });

        Thread t3 = new Thread(()->{
            try {
                t1.join();
            } catch (InterruptedException e) {
                System.out.println("join异常!");
            }
            for (int i = 201; i <= 300 ; i++) {
                System.out.println("t3> "+i);
            }
        });

        //开启线程
        t1.start();
        t2.start();
        t3.start();

    }
}

sleep()和join()的区别:

  1. sleep进入的是有限期等待状态, join进入的是无限期等待状态
  2. sleep是静态方法可以直接通过类名调用, join的非静态的, 必须通过线程对象调用
  3. sleep不会与其他线程产生关联, join一定会与其他线程相互影响

线程池

作用

当线程任务需要多次执行时, 为了防止线程对象的反复创建消耗运行资源, 可以将任务内容写入线程池, 以此确保任务可以反复运行, 直至线程池关闭

API

  1. ExecutorService: 线程池接口
    • submit(任务对象): 提交任务使其执行
      • 线程任务执行结束之后不会销毁, 会回到池中等待下次调用
    • shutdown(): 关闭线程池
  2. Executors: 线程池工具类, 可以用来获取线程池实现类对象
    • newCachedThreadPool(): 获取一个不固定并发数量的线程池
      • 所有提交执行的任务会同时并发交替运行
    • newFixedThreadPool(int ): 获取一个固定并发数量的线程池
      • 会设置同时运行的数量上限, 超出运行上限的任务只能暂时等待, 等执行中的任务执行结束让位之后才能进行执行

线程任务

Runnable

  • run(): 无返回值, 不能上抛异常

    package com.by.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test_ES {
    public static void main(String[] args) {
        //获取线程池对象- 不固定并发数量
     //   ExecutorService es = Executors.newCachedThreadPool();
        //固定并发数量的线程池- 最大同时执行数量为2
        ExecutorService es = Executors.newFixedThreadPool(2);
        //创建线程任务
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100 ; i++) {
                    System.out.println("r1:: "+i);
                }
            }
        };
        Runnable r2=new Runnable() {
            @Override
            public void run() {
                for (int i = 101; i <= 200 ; i++) {
                    System.out.println("r2> "+i);
                }
            }
        };
        Runnable r3=new Runnable() {
            @Override
            public void run() {
                for (int i = 201; i <= 300 ; i++) {
                    System.out.println("r3>>>> "+i);
                }
            }
        };
        //提交任务执行
        es.submit(r1);
        es.submit(r2);
        es.submit(r3);

        //关闭线程池
        es.shutdown();
    }
}
Callable<返回值泛型>

  • call(): 有返回值, 可以上抛异常,默认上抛Exception

  • Future<返回值泛型>: 用来接收存放Callable执行结果

    • Future对象.get(): 获取内部存放的返回值
      • 该方法需要处理非运行时异常
    package com.by.test;

import java.util.concurrent.*;

public class Test_ES2 {
    public static void main(String[] args){
        //获取线程池对象- 不固定并发数量
        ExecutorService es = Executors.newCachedThreadPool();
        //创建线程任务-计算1-100的和并返回
        Callable<Integer> c1=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <=100; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        //提交执行
        Future<Integer> future =es.submit(c1);
        //从future中获取返回值
        try {
            System.out.println(future.get());
        } catch (Exception e) {
            System.out.println("数据异常!");
            e.printStackTrace();
        }

        //关闭线程池
        es.shutdown();
    }
}

线程安全问题

当多个线程同时操作同一个临界资源时, 有可能破坏其原子操作, 从而导致数据缺失, 引发线程安全问题

  • 临界资源: 被多个线程同时访问操作的对象
  • 原子操作: 访问临界资源过程中不可缺失或更改的操作

互斥锁

每个对象都默认拥有的锁. 特点为只有一个锁标记, 且只能被一个线程拥有. 当开启互斥锁之后, 线程想要执行, 则必须同时拥有时间片和锁标记, 拥有资源的线程在执行过程中其他线程不可争抢其资源, 必须保证其原子操作执行同步. 只有当执行线程运行结束释放锁标记之后其他线程才能继续争抢.

Synchronized

作用为开启互斥锁, 使内部原子操作执行同步

同步方法

原理: 在临界资源被访问的方法上加锁

特点: 线程必须同时争抢时间片和锁标记

修饰符 synchronized 返回值类型 方法名(形参列表){
    
}

package com.by.util;

import java.util.ArrayList;
import java.util.List;

/**
 * 工具类- 辅助操作List集合
 */
public class MyList {
    private List<Integer> list = new ArrayList<>();

    /**
     * 往集合属性中添加元素
     * @param n 被添加的数据
     * synchronized: 使该方法成为同步方法, 内部内容的执行不可被破坏
     */
    public synchronized void insert(int n){
        list.add(n);
    }

    //查看集合元素及长度
    public void query(){
        System.out.println("集合长度为:" + list.size());
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
    }
}

同步代码块

原理: 由线程上锁

特点: 上锁线程默认拥有锁标记, 所以线程执行只需要争抢时间片即可

位置: 线程访问临界资源的位置上锁

使用: 必须确保所有访问临界资源的线程都具备加锁操作

synchronized(被加锁的临界资源对象){
    原子操作
}

package com.by.test;

import com.by.util.MyList;

public class Test1 {
    public static void main(String[] args)throws Exception {
        //创建一个工具类对象
        MyList m = new MyList();
        //线程1: 往工具类中的集合里添加1-5
        Thread t1 = new Thread(()->{
            //同步代码块
            synchronized (m) {
                for (int i = 1; i <= 5; i++) {
                     m.insert(i);
                }
            }
        });
        //线程2: 往工具类中的集合里添加6-10
        Thread t2 = new Thread(()->{
            //同步代码块
            synchronized (m) {
                for (int i = 6; i <= 10; i++) {
                    m.insert(i);
                }
            }
        });
        //开启线程
        t1.start();
        t2.start();
        //使t1和t2在主线程查看之前执行
        t1.join();
        t2.join();

        //查看工具类中集合的内容
        m.query();
    }
}

区别:

同步方法: 在被访问的方法上加锁, 线程需要同时争抢时间片和锁标记, 效率慢但是书写简单

同步代码块: 在线程访问临界资源的位置加锁, 线程只需要争抢时间片, 拥有时间片的线程默认拥有锁标记, 执行效率快但是书写繁琐

线程安全的集合类

悲观锁: 悲观的认为集合一定会出现线程安全问题, 所以在底层数组位统一加锁

乐观锁: 乐观的认为集合不会出现线程安全问题, 所以底层并加锁, 当安全问题发生时, 再通过算法解决问题

  • JDK5.0 java.util.concurrent

  1. CopyOnWriteArrayList

    • 原理: 在进行写(增删改)操作时, 先复制出一个副本, 在副本中完成操作, 若副本执行中出现问题, 则舍弃该副本, 重新复制新的副本重复操作, 直至副本中无异常, 再将集合地址转换向副本地址
    • 特点: 舍弃写的效率, 提高读的效率. 适用于读操作远多于写操作时

  2. CopyOnWriteArraySet

    • 原理: 和CopyOnWriteArrayList一致, 在此基础上会对元素进行去重
    • 特点: 和CopyOnWriteArrayList一致

  3. ConcurrentHashMap

    • 原理: CAS算法

    CAS: compare and swap 比较并交换

1SurvivE
关注
专栏目录
java核心技术基础知识Chp14多线程.
08-11
java核心技术
《C__WinForm实践开发教程》chp5.多线程编程技术
11-10
《C__WinForm实践开发教程》chp5
chp5.多线程编程技术
03-04
通俗易懂，很好理解的课件，感觉比看书要有意思，不喜欢看很厚的书又想学C#的可以考虑
《C++程序设计-现代方法》-PPT.zip
07-11
"chp10-多线程.pptx"涵盖了C++的多线程支持，包括线程的创建、同步和通信，这对于编写高性能、并发的现代应用程序是必不可少的。 "chp11-OOD原则.pptx"可能专门讨论面向对象设计的原则，如单一职责原则、开闭原则、...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1630
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
工厂模式的介绍及实现
户伟伟的博客
09-25 142
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 302
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
java将word转pdf
紫月7575的博客
09-30 249
java将word转pdf
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 384
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
JPA+Thymeleaf增删改查
y050505的博客
09-25 492
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 837
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1001
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
最新发布
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 543
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 328
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 285
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 208
记忆中，两个指针合并即可。
一分钟掌握 Java11 新特性
java那些事儿
09-24 641
Java 11 的新特性使得语言更加现代化，增强了代码的可读性和可维护性，同时改善了性能和开发体验。无论是在日常编程中，还是在处理复杂的应用程序时，这些新特性都能够为开发者提供更大的便利。
Linux上Java项目环境安装
2301_76556912的博客
09-25 359
【代码】Linux上Java项目环境安装。
chp6- E-mail Address Search-en
05-15
本章主要介绍如何实现电子邮件地址搜索功能。 首先，我们需要一个包含许多电子邮件地址的数据集。可以使用公开可用的数据集，如Enron邮件数据集或Kaggle的Spam or Ham数据集。也可以使用网络爬虫来收集电子邮件地址...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值