面向对象进阶10

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量66 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43219411/article/details/129061367
版权

一、多线程

1. 什么是线程
  • 线程是一个程序内部的一条执行路径
  • 我们之前启动程序执行后，main方法的执行就是一条单独的执行路径
  • 程序中如果只有一条执行路径，那么这个程序就是单线程的程序
2. 什么是多线程
  • 多线程是指从软硬件上实现多条执行流程的技术

二、多线程的创建

方式一：继承Thread类
  1. Thread类
  • Java通过java.lang.Thread类来代表线程
  • 按照面向对象的实现，Thread类提供了实现多线程的方式
  1. 多线程的实现方案一：继承Thread类
    (1) 定义一个子类MyThread继承线程类java.lang.Thread，重写run（）方法；
    (2) 创建MyThread类的对象
    (3) 调用线程对象的start()方法启动线程（启动后还是执行run方法的）
/**
 * 多线程的创建方式一：继承Thread类实现
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t = new MyThread();
        //4.调用start方法启动线程（执行的还是run方法）
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);

        }

    }
}

/**
 * 1.定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
     * 2.重写run方法，里面定义线程以后要干嘛
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出:" + i);
        }
    }
}

优点：编码简单
缺点：线程类已经继承Thread，无法继承其他类，不利于扩展

  1. 为什么调用start方法不调用run方法
  • 直接调用run方法会当成普通方法执行，此时相当于单线程
  • 只有调用start方法才是启动一个新的线程执行
  1. 把主线程任务放在子线程之前，这样主线程就会一直优先完成
方式二：实现Runnable接口

(1) 定义一个线程任务，实现Runnable接口
(2) 创建MyRunnable任务对象
(3) 把MyRunnable任务对象交给Thread处理
(4) 调用线程对象的start()方法启动线程

public class ThreadDemo2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new MyRunnable();
        //4.把任务对象交给Thread处理
        Thread t = new Thread(target);
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}
/**
 * 1.定义一个线程任务，实现Runnable接口
 */

class MyRunnable implements Runnable{
    /**
     * 2.重写run方法，定义线程的执行任务
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

优点：线程任务只是实现接口，可以继承继承类和实现接口，扩展性强
缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的

方式二的实现方式2：匿名内部类实现
/**
 * 目标：学会线程的创建方式二（匿名内部类方式实现）
 */
public class ThreadDemo2Other {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1执行输出：" + i);
                }
            }
        };
        //4.把任务对象交给Thread处理
        Thread t = new Thread(target);
        t.start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行输出：" + i);
                }
            }
        }).start();

        new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程3执行输出：" + i);
                }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}
方式三：JDK5.0新增：实现Callable接口
1. 前两种线程创建方式存在的问题：
  • 重写的run方法不能直接返回结果
  • 不适合需要返回线程执行结果的业务场景
2. 利用Callable、FutureTask接口实现

(1) 得到任务对象:

    1. 定义类实现Callable接口，重写call方法、封装要做的事情
    1. 用FutureTask把Callable对象封装成线程任务对象

(2) 把线程任务对象交给Thread处理
(3) 调用Thread的start方法启动线程，执行任务
(4) 线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果

public class ThreadDemo3 {
    public static void main(String[] args) {
        //3. 创建任务对象
        Callable<String> call = new MyCallable(100);

        //4. 把Callable任务对象交给FutureTask对象
        // FutureTask对象的作用1：是Runable对象（实现了Runnable接口），可以交给Thread
        // FutureTask对象的作用2:可以在线程执行完毕后通过调用get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.交给线程处理
        Thread t1 = new Thread(f1);
        //6. 启动线程
        t1.start();

        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            //如果f1任务没有执行完，这里的代码会等待，直到线程1跑完才提取结果
            String rs1 = f1.get();
            System.out.println("第一个结果是："+rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = f2.get();
            System.out.println("第二个结果是："+rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 * 1.定义一个任务类，实现Callable接口,应该申明线程任务执行完毕后结果的数据类型
 */

class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    /**
     * 2.重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果
缺点：编程复杂一点

在这里插入图片描述

三、Thread常用方法

public static void main(String[] args) {
        Thread t1 = new MyThread("1号");
        //t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread("2号");
        //t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        //哪个线程执行他，他就得到哪个线程对象（当前线程对象）
        Thread n = Thread.currentThread();
        System.out.println(n.getName());

        for (int i = 0; i < 5; i++) {
            System.out.println("main子线程输出：" + i);
        }
    }

public class MyThread extends Thread{
    public MyThread(){
    }
    public MyThread(String name){
        //为当前线程对象设置名称，送给父类的有参构造器初始化名称
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() +"子线程1输出：" + i);

        }
    }
}

四、线程安全

  • 多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题，称为线程安全问题

五、线程同步

1. 同步思想概述
  • 解决线程安全问题
  • 加锁：把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。
2. 方式一：同步代码块
  • 作用：把出现线程安全问题的核心代码给上锁
  • 原理：每次只能一个线程进入，执行完后自动解锁，其他线程才可以进来执行
synchronized(同步锁对象){
          操作共享资源的代码(核心代码)
}
  • 锁对象要求：理论上锁对象只要对于当前同时执行的线程来说是同一个对象即可。
  • 锁对象用任意唯一的对象不好，会影响其他无关线程的执行
  • 建议使用共享资源作为锁对象，对于实例方法建议使用（this），静态方法建议使用（类名.class）
3.方式二： 同步方法
  • 作用：把出现线程安全问题的核心代码给上锁
  • 原理：每次只能一个线程进入，执行完后自动解锁，其他线程才可以进来执行
修饰符 synchronized 返回值类型 方法名称(形参列表){
          操作共享资源的代码
}
4.方式三： Lock锁
  • 更清晰的表达如何加锁和释放锁
  • Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
  • Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。
private final Lock lock = new ReentrantLock();
...
lock.lock();//上锁
...
lock.unlock();//解锁

六、线程通信(了解)

  1. 什么是线程通信、如何实现？
  • 线程之间相互发送数据，线程通信通常通过共享一个数据的方式实现
  • 线程间会根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做
  1. 线程通信常见模型
  • 生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费数据
  • 要求：生产者线程生产完数据后，唤醒消费者，然后等待自己；消费者消费完该数据后，唤醒生产者，然后等待自己。

七、线程池(重点)

线程池概述

（1）什么是线程池？

  • 线程池是一个可以复用线程的技术

（2）不使用线程池的问题

  • 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销很大，严重影响系统性能。
线程池实现的API、参数说明

（1）谁代表线程池

  • JDK 5.0提供了代表线程池的接口：ExecutorService

（2）如何得到线程池对象

  • 方式一：使用ExecutorService的实现类ThreadPoolExecutor
  • 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

（3）线程池面试题

  • 临时线程什么时候创建？
    新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程
  • 什么时候会开始拒绝任务？
    核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝
线程池处理Runnable任务
  • 使用ExecutorService的方法
  • void execute(Runnable target)
线程池处理Callable任务
  • 使用ExecutorService的方法
  • Future<T> submit(Callable<T> command)
Executors工具类实现线程池
  • Executors的底层其实是基于线程池的实现类ThreadPoolExecutor创建线程池对象的
  • 大型并发系统环境中使用Executors如果不注意可能会出现系统风险
public static void main(String[] args) throws Exception{
        //1.创建固定线程数量的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable()); //已经没有多余线程
    }

八、定时器

  1. 定时器
  • 控制任务延时调用，或者周期调用的技术
  • 作用：闹钟、定时邮件发送
  1. 定时器的实现方式
  • 方式一：Timer
  • 方式二：ScheduledExecutorService
  1. Timer定时器
public static void main(String[] args) {
        //1.创建Timer定时器
        Timer timer = new Timer();
        //2.调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行一次");
            }
        }, 3000,2000);
    }
  • 存在的问题：
    （1） Timer是单线程，处理多个任务按照顺序执行，存在延迟与设置定时器的时间有出入
    （2）可能因为其中的某个任务异常使Timer线程死掉，从而影响后续任务执行
  1. ScheduledExecutorService定时器
  • 弥补Timer的缺陷，ScheduledExecutorService内部为线程池
  • 优点：基于线程池，某个任务的执行情况不会影响其他定时任务的执行
public static void main(String[] args) {
        //1.创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        //2.开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出：AAA" + new Date());
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出：BBB" + new Date());
            }
        },0,2, TimeUnit.SECONDS);
    }

补充知识：并发、并行、生命周期

  1. 并发与并行
  • 正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的
  • 并发的理解：（分时轮询的执行线程）
    CPU同时处理线程的数量有限；
    CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发
  • 并行的理解：（同一时刻同时在运行）
    在同一时刻上，同时有多个线程在被CPU处理并执行
  1. 生命周期
  • 线程的状态：也就是线程从生到死的过程，以及中间经历的各种状态及状态转换
  • 理解线程状态有利于提升并发编程的理解能力
  • Java线程的状态：
    Java共6种状态，定义在Thread类的内部枚举类中：新建、就绪、阻塞、等待、计时、结束
    在这里插入图片描述
    在这里插入图片描述
枯芥子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable
一个恶意卖萌的博客
05-09 3248
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable 问题描述： Arrays.sort不能对自定义对象进行排序。现希望对自定义的PersonSortable类的对象，使用Arrays.sort进行排序。 1.编写PersonSortable类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toStr...
Python面向对象进阶学习
09-19
在本文里我们整理了关于Python面向对象的进阶学习知识点以及学习路线等内容，有兴趣的朋友们学习下。
java对一个对象加锁，锁的是什么东西？
分享Java技术知识，共同成长进步！
09-19 1274
线程同步相关知识详解。 一、同步代码块 作用：把出现线程安全问题的核心代码给上锁 原理：每次只能一个线程进入，执行完毕后自动解决，其他线程才可以进来执行。 synchronized(同步锁对象) { 操作共享资源的代码(核心代码) } 锁对象要求 理论上：锁对象只要对于当前同时执行的现成来说是同一个对象即可。 锁对象用任意唯一的对象好不好呢？ 不好，会影响其他无关线程的执行。 锁对象的规范要求 规范上：建议使用共享资源作为锁对象。 对于实例方法建议使用this作为锁对象。
99-Java的多线程：安全问题、模拟线程安全问题案例：取款；同步、同步代码块、同步方法、同步锁
yelitoudu的博客
10-07 1191
Java的多线程：安全问题、模拟线程安全问题案例：取款；同步、同步代码块、同步方法、同步锁
Java面向对象（进阶）
Ironsb的博客
10-24 205
Java面向对象进阶知识
面向对象进阶
queenbao621的博客
06-15 1223
1、比较成员变量和局部变量的区别 成员变量也称为属性、 Java中的成员变量分为类属性和实例属性两种，定义属性时没有static修饰符修饰的就是实例属性、
06面向对象进阶
Yang_Jin_的博客
04-01 244
面向对象进阶 JVM内存的分配 编译器将.java文件转化为.class文件 .class文件被交给类加载器（三种）----在内存中分配空间 JVM（java虚拟机）会将内存分为5块： 栈：java栈的区域比较小，空间1M，特点：（存取数据）速度非常快，在栈里执行的基本上都是快速任务，存基本数据类型和对象的引用 堆：new出来的对象都存放在堆里面，堆里面的每一个对象都会产生一个唯一的地址，内存地...
java面向对象进阶
xiaomuwuya的博客
06-10 1123
java的面向对象指的是将我们的现实当中的事物抽象成一段java代码来描述，那现实当中的实体对象具有哪些方面是需要用代码的描述？ 任何一个类需要从两方面描述 1、特征、属性 —-一定时间范围内不会变化 2、行为、功能、方法 — 该类事物可以发出的动作 在java里面概括为 属性 和 方法(函数) ...
JAVA面向对象进阶
weixin_58835941的博客
06-15 1262
一：成员变量 在java中，变量可以分为成员变量和局部变量，成员变量是定义在类范围内的变量，局部变量是定义在方法中的变量。
Java 面向对象进阶 10 多态中调用成员的特点（黑马）
qq_53390480的博客
02-21 357
如果时Dog d = new Dog();那么就直接区子类找name，不会先去父类开始找，找不到再到父类去找；如果调用成员方法时，编译时发现父类没有该方法，就会标红。
面向对象进阶笔记
lzy520o的博客
05-03 134
面向对象进阶 封装private 封装的意义在于保护或防止代码（数据）被无意中破坏。 保护成员属性，不让类以外的程序直接访问和修改； 封装的原则：隐藏对象的属性和实现细节，仅对外公开访问方法，并控制访问级别。 在开发中为了避免逻辑错误，建议对所有属性进行封装，为其提供setter和getter方法进行设置和取得 操作。 this关键字 表示当前对象 能完成的操作： 调用类中的属性 调用类中的方法或...
python进阶_浅谈面向对象进阶
09-21
下面小编就为大家带来一篇python进阶_浅谈面向对象进阶。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Python面向对象进阶教程,Python面向对象进阶知识笔记.doc
10-01
本文将深入探讨Python面向对象编程的进阶知识，包括类方法、静态方法、`__new__`和`__init__`方法以及单例模式。 1. **类方法**： 类方法是通过装饰器`@classmethod`标识的方法，它们的第一个参数通常是`cls`，...
面向对象进阶，面向对象进阶
09-10
本节我们将深入探讨面向对象的进阶概念，包括封装、继承、多态以及接口等核心原则，帮助开发者更好地理解和运用这一强大的编程范式。 1. 封装：封装是面向对象的基础，它将数据和操作数据的方法绑定在一起，形成一...
python面向对象进阶之路
12-21
众所周知，python是门面向对象编程语言，面向对象是一个程序设计和编程思想，即一切皆为对象。 面向对象 面向对象三要素：封装，继承， 多态 封装？ 把一致的行为或者公共的部分封装成一个类或者方法。 比如把一定...
配置Java开发环境
Broken_x的博客
07-10 1608
Java开发环境配置
java集合工具类
最新发布
药的博客
07-12 447
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 563
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 304
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
Java面向对象（进阶）- 面向对象特征之三：多态性
11-11
Java面向对象（进阶）-- 面向对象特征之三：多态性

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值