JavaSE进阶——Day12——多线程

于 2023-04-05 17:13:17 发布
阅读量139 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyl_010825/article/details/129973406
版权

今日内容

  • 进程、线程介绍

  • java中线程的实现方式

    • thread类

    • Runnable接口

    • Callable接口

  • 线程相关的方法

  • 线程安全问题-同步技术

  • 线程等待唤醒机制

1-进程和线程介绍

1.1-进程（Process）

简单理解：进程就是正在运行的程序

进程的特性

  • 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。

    进程是操作系统的最小调度单元

    在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他的进程的地址空间。

  • 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。

并发性：任何进程都可以同其他进程一起并发执行

  • 并行：在同一时刻，有多个指令在多个CPU上【同时】执行

  • 并发：在同一时刻，有多个指令在单个CPU上【交替】执行

多进程同时执行的本质

大部分操作系统都支持多进程并发运行：表面上是并行，实际是并发

1.2-线程（Thread）

  • 操作系统可以同时执行多个任务，每个任务就是进程，进程可以同时执行多个任务，每个任务就是线程。

  • 线程依赖于进程，线程是进程执行的最小单元。一个进程至少应该存在一个线程。

多线程的意义

随着处理器上的核心数量越来越多，现在大多数计算机都比以往更加擅长并行计算

而一个线程，在一个时刻，只能运行在一个处理器核心上

试想一下，一个单线程程序，在运行时只能使用一个处理器核心，那么再多的处理器核心加入也无法显著提升该程序的执行效率。

相反，如果该程序使用多线程技术，将计算逻辑分配到多个处理器核心上，就会显著减少程序的处理时间，并且随着更多处理器核心的加入而变得更有效率。

总结：使用多线程可以提高程序的执行效率

  • 问题：什么是进程？什么是线程？

    进程：正在运行的程序

    线程：指的就是程序中的任务

  • 单线程：程序只有一条执行路径

  • 多线程：程序有多条执行路径

2-Java中线程的实现方式

Java程序默认就是多线程的

  1. 主线程 ： 正常执行逻辑，可能会制造垃圾对象

  2. 垃圾回收线程 ： 监控垃圾数量，达到一定量后，清理垃圾对象

2.1-继承Thread类

方法介绍

实现步骤

  1. 找一个类继承Thread

  2. 重写run方法

  3. 将线程要执行的任务，写在run方法中

  4. 创建线程对象 

  5. 调用内部start方法开启线程

    • 重点：只要调用start方法开启线程，内部就会自动调用run方法

    • 注意：如果使用线程对象调用run方法，没有开启新的线程，只是调用了对象的一次方法而已

package com.lyl.thread;
​
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        for (int i = 1; i <= 2000; i++) {
            System.out.println("main线程执行了--------------" + i);
        }
    }
}
​
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 2000; i++) {
            System.out.println("run方法执行了" + i);
        }
    }
}

运行结果：

 

两个小问题

  • 为什么要重写run方法？

  • 因为run()是用来封装被线程执行的代码

  • run方法和start方法的区别？

  • run():封装线程执行的代码，直接调用，相当于普通方法的调用

  • start():启动线程；然后由JVM调用此线程的run()方法

继承Thread类用的少，因为java不支持多继承

2.2-实现Runnable接口

推荐使用

实现步骤

  1. 找一个类实现Runnable接口

  2. 重写run方法

  3. 将线程要执行的任务，写在run方法中

  4. 创建线程任务对象

  5. 创建线程对象（Thread），将【线程任务】对象，传递给【线程】对象

  6. 调用线程对象的start方法开启线程

package com.lyl.thread;
​
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread th = new Thread(mr);
        th.start();
        for (int i = 1;i<=2000;i++){
            System.out.println("main线程打印---------"+i);
        }
    }
}
class MyRunnable implements Runnable{
​
    @Override
    public void run() {
        for (int i = 1;i<=2000;i++){
            System.out.println("MyRunnable线程打印"+i);
        }
    }
}

运行结果：

 

2.3-实现Callable接口

前两种都是没有返回值的，而这种方式的特点：线程任务执行完毕后，是可以有结果返回的

实现步骤

  1. 找一个实现类实现Callable，泛型为运算后的结果类型

  2. 重写call方法，将线程任务写在call方法中

  3. 创建线程对象

  4. 创建FutureTask线程任务对象【中间媒介】，将该线程任务对象进行封装

  5. 创建线程对象，将封装好的线程任务，传入构造方法

  6. 调用start方法开启线程

  7. 通过【中间媒介】线程任务对象的get方法，获取结果

  • 注意：get方法具有阻塞效果

package com.lyl.thread;
​
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<>(mc);
        Thread t = new Thread(ft);
        t.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("main线程执行-------"+i);
        }
        System.out.println(ft.get());
    }
}
class MyCallable implements Callable<Integer>{
​
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 2000; i++) {
            sum += i;
            System.out.println("MyCallable线程执行累加操作："+sum);
        }
        return sum;
    }
}

运行结果：

 

使用场景

当线程具有返回值时使用

2.4-三种实现方式的对比

  • 实现Runnable、Callable接☐

好处：扩展性强，实现该接口的同时还可以继承其他的类

缺点：编程相对复杂，不能直接使用Thread类中的方法

  • 继承Thread类

好处：编程比较简单，可以直接使用Thread类中的方法

缺点：可以扩展性较差，不能再继承其他的类

3-线程中的相关方法

3.1-设置和获取线程名称

  • 获取线程名字：getName【通过线程对象调用】

  • Thread.currentThread()：获取当前执行的线程对象

  • 修改线程名字：setName【或者直接在线程对象第二个参数中设置名字】

代码演示

package com.lyl.thread;
​
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread th = new Thread(mr,"线程A：");
        th.start();
        for (int i = 1; i <= 2000; i++) {
            System.out.println("main线程打印---------" + i);
        }
    }
}
​
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 2000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程打印" + i);
        }
    }
}

 

运行结果：

 

练习

请定义两个线程，一个线程可以计算1--100所有数字的累加和，另一个线程可以计算1--100所有数字的累加和，每个线程计算完毕后各自打印计算结果格式例如："XXX线程计算1--100的累加和，结果：XXX"，请定义测试类，并定义main()方法，启动两个线程，观察控制台打印结果。

package com.lyl.test;
​
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程任务对象
        GetSumTask gst = new GetSumTask();
        //俩线程任务对象媒介
        FutureTask<Integer> ft1 = new FutureTask<>(gst);
        FutureTask<Integer> ft2 = new FutureTask<>(gst);
        //俩线程对象
        Thread t1 = new Thread(ft1,"线程A： ");
        Thread t2 = new Thread(ft2,"线程B： ");
        //开启俩线程
        t1.start();
        t2.start();
        //打印
        System.out.println(t1.getName()+"线程计算1--100的累加和，结果："+ft1.get());
        System.out.println(t2.getName()+"线程计算1--100的累加和，结果："+ft2.get());
​
    }
}
class GetSumTask implements Callable<Integer>{
​
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

运行结果：

线程A： 线程计算1--100的累加和，结果：5050

线程B： 线程计算1--100的累加和，结果：5050

3.2-线程休眠

方法名说明
static void sleep(long millis)使当前正在执行的线程停留（暂停执行）指定的毫秒数

代码演示

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
​
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*
            System.out.println("睡觉前");
            Thread.sleep(3000);
            System.out.println("睡醒了");
        */
​
        MyRunnable mr = new MyRunnable();
​
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
​
        t1.start();
        t2.start();
    }
}

3.3-线程优先级

线程调度

  • 两种调度方式

    • 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片

    • 抢占式调度模型：优先让优先级高的线程使用CPU,如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些

  • Java使用的是抢占式调度模型

    • 随机性

    • 假如计算机只有一个CPU,那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

方法名说明
final int getPriority()返回此线程的优先级
final void setPriority(int newPriority)更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

代码演示

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        // 优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();
​
        FutureTask<String> ft = new FutureTask<>(mc);
​
        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        // System.out.println(t1.getPriority());//5
        t1.start();
​
        MyCallable mc2 = new MyCallable();
​
        FutureTask<String> ft2 = new FutureTask<>(mc2);
​
        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        // System.out.println(t2.getPriority());//5
        t2.start();
    }
}

4-线程同步

卖票案例

  • 案例需求

  • 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

同步代码块解决数据安全问题

安全问题出现的条件

是多线程环境

有共享数据

有多条语句操作共享数据

如何解决多线程安全问题呢？

基本思想：让程序没有安全问题的环境

怎么实现呢？

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

Java提供了同步代码块的方式来解决

同步代码块格式：

synchronized(锁对象){
被锁的代码块;
}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

同步的好处和弊端

  • 好处：解决了多线程的数据安全问题

  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

代码实现

package com.lyl.test;
​
public class TicketTest1 {
    public static void main(String[] args) {
​
        Ticket t1 = new Ticket();
        t1.setName("窗口A： ");
        Ticket t2 = new Ticket();
        t2.setName("窗口B： ");
        Ticket t3 = new Ticket();
        t3.setName("窗口C： ");
​
        t1.start();
        t2.start();
        t3.start();
​
    }
}
class Ticket extends Thread{
    static int tickets = 10000;
​
    @Override
    public void run() {
        while (true){
            //上锁
            synchronized (Ticket.class) {
                if (tickets == 0){
                    break;
                }else {
                    System.out.println(getName()+"卖出了第"+tickets+"张票");
                    tickets--;
                }
            }
        }
    }
}

同步方法解决数据安全问题

  • 同步方法的格式

    同步方法：就是把 synchronized 关键字加到方法上

    修饰符 synchronized 返回值类型 方法名(方法参数) { 
    方法体；
}

    同步方法的锁对象是什么呢? 答：this

  • 静态同步方法

  • 静态同步方法：就是把synchronized关键字加到静态方法上

    修饰符 static synchronized 返回值类型 方法名(方法参数) { 
    方法体；
}

    同步静态方法的锁对象是什么呢? 类名.class

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

  • ReentrantLock构造方法

方法名说明
ReentrantLock()创建一个ReentrantLock的实例

  • 加锁解锁方法

方法名说明
void lock()获得锁
void unlock()释放锁

代码演示

public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();
    private ReentrantLock lock = new ReentrantLock();
​
    @Override
    public void run() {
        while (true) {
            //synchronized (obj){//多个线程必须使用同一把锁.
            try {
                lock.lock();
                if (ticket <= 0) {
                    //卖完了
                    break;
                } else {
                    Thread.sleep(100);
                    ticket--;
                    System.out.println(Thread.currentThread().getName() 
                                                        + "在卖票,还剩下" + ticket + "张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
​
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
​
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
​
        t1.start();
        t2.start();
        t3.start();
    }
}

死锁

  • 概述

    线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行

  • 什么情况下会产生死锁

    1. 资源有限

    2. 同步嵌套

  • 代码演示

    public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();
​
        new Thread(()->{
            while(true){
                synchronized (objA){
                    // 线程一
                    System.out.println(Thread.currentThread().getName() + "----抢到了执行权, 上A锁");
                    synchronized (objB){
                        System.out.println(Thread.currentThread().getName() + "----抢到了执行权, 上B锁");
                    }
                }
            }
        }).start();
​
        new Thread(()->{
            while(true){
                synchronized (objB){
                    // 线程二
                    System.out.println(Thread.currentThread().getName() + "----抢到了执行权, 上B锁");
                    synchronized (objA){
                        System.out.println(Thread.currentThread().getName() + "----抢到了执行权, 上A锁");
                    }
                }
            }
        }).start();
    }
}

5-线程的等待唤醒机制

生产者和消费者模式概述

  • 概述

    生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。

    所谓生产者消费者问题，实际上主要是包含了两类线程：

    一类是生产者线程用于生产数据

    一类是消费者线程用于消费数据

    为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

    生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

    消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

  • Object类的等待和唤醒方法

方法名说明
void wait()导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify()唤醒正在等待对象监视器的单个线程
void notifyAll()唤醒正在等待对象监视器的所有线程

生产者和消费者案例

public class Box {
    public static boolean flag = false;
}
​
​
public class Consumer extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Box.class) {
                if (Box.flag == false) {
                    // 等待
                    try {
                        System.out.println("没有包子了, 消费者等待...");
                        Box.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println("消费者开吃....");
                    Box.flag = false;
                    Box.class.notifyAll();
                }
            }
        }
    }
}
​
public class Maker extends Thread{
    @Override
    public void run() {
        while(true){
            synchronized (Box.class) {
                if(Box.flag == false){
                    // 没包子了, 生产者制作
                    System.out.println("生产制作包子....");
                    Box.flag = true;
                    Box.class.notifyAll();
                }else {
                    // 有包子, 生产者等待
                    System.out.println("有包子, 生产者等待");
                    try {
                        Box.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
​
public class Test {
    public static void main(String[] args) {
        Consumer c = new Consumer();
        Maker m = new Maker();
​
        c.start();
        m.start();
    }
}

安生°
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程 封装_【JAVA多线程概述】
weixin_39779975的博客
02-25 386
一、多线程概述一个进程中至少有一个线程，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。不能没一个问题都使用多线程，能使用单线程解决的问题就不要使用多线程解决。使用多线程的弊端：一旦开启了多个程序，电脑就会变卡，原因就是每个程序被CPU处理的几率变小了。最明显的例子就是如果在复制文件的时候如果开启了多个其他程序，则复制文件所需要的时间就会明显变长。使用多核CPU可以解决一部分问题，...
java线程池封装
05-24
java线程池封装，可自定义线程优先级，使用方便。。。
java多线程工具类封装（有返回值和无返回值）
最新发布
weixin_40593587的博客
08-02 1097
多线程，工具类
Java线程简介
TravelAlone的博客
09-10 495
一、线程概念 线程，有时被称为轻量级进程，是程序执行流的最小单元。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。 线程状态： （1）新建。当一个线程对象被声明并创建时，新生的线程对象处于新建状态。 （2）就绪。处于新建状态的线程被启动后，即可拥有相应的内存空间和所属的资源。 （3）运行。处于就绪状态的线程被调度并获得CPU资源时，便处于运行状态。 （4）阻塞。一个正在运行的
Java网络编程socket通讯简单封装(使用多线程)_20170808_LK
08-08
Java网络编程socket通讯简单封装(使用多线程)
JavaSE教程——布小禅.docx
09-18
JavaSE教程——布小禅.docx，专门为零基础人设计的教程
JavaSE实战——客户端上传文件到服务端
05-05
4. **多线程**：在服务端，通常会用到多线程技术，因为服务器可能同时处理多个客户端的请求。每个客户端的Socket连接都可以看作一个独立的任务，我们可以创建一个ServerSocket监听客户端连接，每当有新的连接到来，...
JavaSE多线程编程专题.pptx
06-08
JavaSE多线程编程专题
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
java线程简单的封装类
06-11
用反射实现了对java线程简单的封装，类似c#线程，使用此封装类勿需再次继承Thread类或实现Runnable接口，直接绑定需要使用线程的方法即可，另支持动态传参，如觉着好用请多多支持作者 QQ 359103820 希望能为使用线程的地方带来方便！
java 线程安全 是程序执行流的最小单元
03-29
　线程(thread),有时被称为轻量级进程(Lightweight Process，LWP)，是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC)，寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。
java封装的几个线程池介绍
Widsom的博客
06-09 4546
java封装的几个线程池介绍FixedThreadPoolFixedThreadPool并不是一个类，它是由Executors工具类创建出来的一个固定线程数的一个ThreadPoolEexcutor的对象，有2种实现方式。Executors.newFixedThreadPool(3);//固定3个线程数Executors.newFixedThreadPool(3, Executors.default
线程池封装类—借鉴ImageLoader的线程工厂
年少的风
02-18 2652
在Android开发过程中免不了需要使用异步线程，但是在项目中大量使用 new Thread() { public void run() { // do sth }; }.start();会造成很多野线程，不但不易维护，在性能上也是有一定折扣。 ps
关于Spring封装Java线程池的理解
11-27 2601
项目用到了TaskExecutor,我看有的是通过spring bean配置的.有的是通过配置的方式，于是看了下官方文档，官方文档（好像是第30.5章）上写的很清楚，里面的参数的含义等东东， <task:executor id="asyncTaskExecutor" pool-size="${e
Java多线程实现的四种方式
热门推荐
Scott的专栏
07-19 11万+
Java多线程实现的方式有四种 1.继承Thread类，重写run方法 2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池创建线程前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果 后面
Java线程 封装 沉睡与唤醒
moonmuzi的博客
03-16 684
public abstract class MyThread extends Thread {     private boolean suspend = false;     private String control = ""; // 只是需要一个对象而已，这个对象没有实际意义     public void setSuspend(boolean suspend) {        if (...
【Java】一个标准的后台线程的封装
weixin_33713503的博客
05-02 288
前言： 我们日常总会碰到这样的需求： 把这个任务放到另外一个线程执行。 我需要周期性执行任务的线程。那我们通常都是怎么解决这个问题呢？ 对于问题1，最简单的做法就是new thread，然后结束了。但在生产环境中，你常常会困扰，我这个线程到底执行没，或者是否正在执行。任务报错了日志在哪里呢？ 对于问题2，我们可能会选择定时器，ScheduledExecutor，但如果你想追踪你的线程运行情况，...
java线程封装_Java 多线程处理任务的封装【转】
weixin_34017901的博客
02-12 218
使用方法很简单，有两种使用方法1.直接传递一批任务给到多线程处理方法，返回处理结果代码如下:/*** Created with IntelliJ IDEA.* 测试多线程处理任务* className: TaskMulThreadServiceTest** @version 1.0* Date Time: a*@author: ddys*/public class TaskMul...
JavaSE进阶：常用类深度解析
"动力节点的JavaSE进阶课程涵盖了Java编程中的常用类，包括String、StringBuffer、基础类型包装类、日期相关类、数字相关类、Random类和Enum。这些知识点对于深入理解和应用Java语言至关重要。" 在Java编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值