Java多线程

已于 2022-06-26 15:20:41 修改
阅读量135 收藏
点赞数
文章标签： java 开发语言
于 2022-06-26 14:28:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62555808/article/details/124736371
版权

程序、进程、线程

  1. 程序：一段静态的代码，静态对象

  2. 进程：正在运行的一个程序，是一个动态的过程，有生命周期。进程作为资源分配的单位，系统在运行时会为每个进程分配内存区域。
  3. 线程：进程可以进一步细化为线程，同一个进程可以支持多个线程就叫多线程，线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器
  • 每个线程各自有一套虚拟机栈和程序计数器
  • 每个进程各有一份方法区和堆
  • 单核CPU和多核CPU：一个JAVA应用程序至少有三个线程，main主线程，gc()垃圾回收线程，异常处理线程
  • 并行和并发：

并行——多个CPU同时执行多个任务，如：多个人同时做不同的事儿。

​ 并发——一个CPU同时执行多个任务，如：秒杀、多个人做同一件事。


使用多线程的优点

1、提高程序的响应。对图形化界面更有意义，可增强用户体验

2、提高计算机系统CPU的利用率

3、改善程序结构，进程分为线程独立运行，有利于理解和修改

线程的创建和使用

方式一：继承于Thread类

1、创建Thread类的子类

2、重写Thread类的run()方法——>将此线程执行的操作声明在run方法中

3、创建Thread类的子类对象

4、通过此对象调用start()：作用（1）启动当前线程；（2）调用当前线程的run()

package java5;

//1、创建Thread类的子类
class MyThread extends Thread{
    //2、重写Thread类的run()方法
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        //MyThread t1 = new MyThread();
        MyThread t1 = new MyThread();//这里new MyThread()之后直接alt + enter就可以造对象了

        //4、通过此对象调用start()
        t1.start();

    }
}

问题：

  1. 不能通过run()的方式执行线程，用run()只是普通的调用方法，一定！一定！要是 start()
  2. 如果还要再启动一个线程，就再新造一个MyThread对象，再start()——要想启动多个线程，就要去造多个对象，再去调start()方法。
package java5;

public class ThreadDemo {
    /*
    练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个遍历100以内的奇数。
     */
    public static void main(String[] args) {
//        MyThread1 m1 = new MyThread1();
//        MyThread2 m2 = new MyThread2();
//        m1.start();
//        m2.start();

        //上面的四行还可以改成创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100;i++){
                    if(i % 2 == 0)
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100;i++){
                    if(i % 2 != 0)
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }.start();
    }

}
class MyThread1 extends Thread{
    public void run(){
        for (int i = 0; i < 100;i++){
            if(i % 2 == 0)
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}
class MyThread2 extends Thread{
    public void run(){
        for (int i = 0; i < 100;i++){
            if(i % 2 != 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

Thread里的常用方法：

  • start()：①启动当前线程 ②调用当前线程的run()
  • run()：通常需要重写此方法
  • currentThread()：静态方法，返回执行当前代码的线程
  • getName()：获取当前线程的名字
  • setName()：设置当前线程的名字
  • yield()：释放当前CPU的执行权
  • join()：在线程A中调用B的该方法，线程A进入阻塞状态直到线程B执行完之后线程A才继续执行
  • sleep()：让当前线程强制阻塞

线程的优先级：

  1. MAX——10，MIN——1，NORM——5（默认的优先级）
  2. 涉及的方法：getPriority()——返回线程的优先值，setPriority()——改变线程的优先级
  3. 高优先级的线程不一定就先执行，只是大概率先执行。

方式二：实现Runnable接口

  1. 创建一个实现Runnable接口的类.
  2. 实现类实现Runnable中的抽象方法：run()方法.
  3. 创建实现类的对象.
  4. 将对象作为参数传递到Thread类的构造器中，创建Thread类的对象.
  5. 通过此对象调用start()方法.
package java5;
/*
例子：创建三个窗口卖票，总票数为100张，使用实现Runnable接口的方式
 */
class Window1 implements Runnable{
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket --;
            }else{
                break;
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);//这里形参都是m，本身就可以实现共享数据


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

两种方式的对比

开发中：优先选择，实现Runnable接口的方式。

原因：Runnable没有单继承性的局限性，更适合多个线程共享数据的情况.

相同点：都需要重写run并且将线程要执行的逻辑声明在run()中.

线程的生命周期

线程的同步（解决线程安全问题） 

方式一：同步代码块

synchronized(同步监视器）{

        //需要被同步的代码

}

说明：1.操作共享数据的代码，即为需要被同步的代码，包含的代码一定要刚刚好，不能少也不能多。

        共享数据：多个线程共同操作的变量。如卖票中的ticket。

        2.同步监视器俗称“锁”。任何一个类的对象，都可以充当锁。

要求：多个线程必须要共用同一把锁。（实现的方式中一般写在run()方法前面；继承的方法中，要把synchronized声明为static，确保共享数据是唯一的）

实现类方法

package java5;


    /*
    例子：创建三个窗口卖票，总票数为100张，使用实现Runnable接口的方式
     */
    class Window1 implements Runnable{
        private static int ticket = 100;
        Object obj = new Object();//锁，这个obj一定要是共用的，唯一的，放的位置要正确
        public void run(){
            synchronized(obj){
                while(true){
                    if(ticket > 0){
                        System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                        ticket --;
                    }else{
                        break;
                    }
                }
            }
        }



    }

    public class WindowTest {
        public static void main(String[] args) {
            Window1 w = new Window1();

            Thread t1 = new Thread(w);
            Thread t2 = new Thread(w);
            Thread t3 = new Thread(w);

            t1.setName("窗口一");
            t1.setName("窗口二");
            t1.setName("窗口三");


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

        }
    }

（1）实现类方法可以使用this，就不用每次再造对象了。

（2）继承类方法可以用类去充当同步监视器——synchronized（Window2.class——类也是对象，万物皆对象）这里的Window2只会加载一次，this要慎用，一定要注意唯一性！！

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，就把这个方法弄成同步方法。

1、同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

2、非静态的同步方法（一般是实现Runnable类的方式），同步监视器是this；静态的同步方法（一般是继承thread类的方式），同步监视器是：当前类本身

//同步方法+实现Runnable
class MyRun implements Runnable{
    private static int ticket=100;
    @Override
    public void run(){
        show();//先同步方法，然后把这个方法包到run方法中
    }
    public synchronized void show(){//这里的同步监视器就是this
        for (tikect>0) {
            System.out.println(getName()+"买票，票号为："+ticket);
            ticket--;
        }
    }
}
public static void main(String[] args) {
    MyRun r=new MyRun();
    
    Thread t1=new Thread(r);
    Thread t2=new Thread(r);
    Thread t3=new Thread(r);
    t1.start();
    t2.start();
    t3.start();
}
//同步方法+实现Thread类
class MyThread extends Thread{
    private static int ticket=100;
    @Override
    public void run(){
        show();
    }
    public static synchronized void show(){//必须是静态的,这里的同步监视器是当前类
        for (tikect>0) {
            System.out.println(Thread.currentThread.getName()+"买票，票号为："+ticket);
            ticket--;
        }
    }
}

同步使得速度变慢，但是为了安全，还是需要用的。

线程安全的单例模式：懒汉式

原始的两种模式：

（1）懒汉式（延迟对象的创建，线程不安全）

package java5;

public class SingleTest2 {
    public static void main(String[] args) {

        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);

    }
}
//懒汉式，什么时候需要用，什么时候造对象
class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类对象，没有初始化,对象必须为static
    private static Order instance = null;//主要区分点private static Bank instance = new Bank();

    //3.声明public,static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }


}

（2）饿汉式（对象的加载时间过长，它是线程安全的）

package java5;

/**
 * 单例设计模式（某个类只能存在一个实例）
 *
 */
public class SingletonTest1 {
    public static void main(String[] args) {

        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);

    }
}
//饿汉式，先提前造好对象
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }
    //内部创建类的静态对象
    private static Bank instance = new Bank();//private用不了，所以要有公共的方法

    //提供公共的静态方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }


}

线程安全的懒汉式

class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类对象，没有初始化,对象必须为static
    private static Order instance = null;//主要区分点private static Bank instance = new Bank();

    //3.声明public,static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            synchronized(Bank.class){
                if(instance == null){
                    instance = new Order();
                }
            }
        }
        return instance;
    }
}

死锁的理解

1、同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃，造成了线程的死锁，没有异常没有提示，但所有线程都在阻塞状态。

Lock(锁)

1、synchronized与Lock的异同？

同：二者都可以解决线程安全问题

异：Lock自动锁定和解锁，synchronized在执行完相应的同步代码块之后，自动地释放同步监视器，Lock需要手动的启动同步——Lock（）,同时结束同步也需要手动的实现——unlock()

优先顺序：

Lock——>同步代码块——>同步方法

线程的通信

涉及到的三个方法：

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器

notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的

notifyall():一旦执行此方法，就会唤醒所有被wait的线程

说明：1.这三者必须是只能出现在同步代码块和同步方法中

2,这三个方法的调用者必须是同步代码块或同步方法中同步监视器。否则出现异常。

3.这三个方法是定义在java.lang.Object类中。

面试题：sleep()和wait()的异同：
同：一旦执行，就会使线程进入阻塞状态。

异：（1）声明的位置不同，Thread类中声明sleep(),Object类中声明wait()

(2)调用要求不同，sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或者同步方法中

（3）关于是否释放同步监视器？ 

如果两个方法都使用在同步代码块或者同步方法中，sleep()不会释放锁，而wait()会释放锁。

线程通信例题：消费者，生产者问题



*生产者(Productor)将产品交给店员(CLerk),而消费者(Customer)从店员处取走产品,

店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员

会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品

了，店员会告诉消费者等一下，如果店中有产品J通知消费者来取走产品。
 

问题思考：

是否是多线程问题？——生产者线程，消费者线程

是否有共享数据？——是，店员（或者产品）

如何解决线程安全问题？——同步机制，有三种方法

是否设计线程通信？是

package java5;


import java.util.Properties;

class Clerk{

    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
        if(productCount < 20){
            productCount ++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");
            notify();
        }else{
            try {
                wait();//有wait()，一般都要有notify()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
//消费产品
    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount --;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread{//涉及线程问题——实现？继承？
    private Clerk clerk;

    public Producer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始生产产品。。。。");
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//让时间更久一些
            clerk.produceProduct();
        }
    }
}


class Customer extends Thread{
    private Clerk clerk;

    public Customer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始消费产品。。。。");
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Customer c1 = new Customer(clerk);
        c1.setName("消费者1");

        p1.start();
        c1.start();
    }
}

新增多线程的方式——实现callable接口（建议使用）

使用的好处：
1、call（）可以有返回值。

2、call()可以抛出异常，被外面的操作捕获，获取异常的信息

3、callable是支持泛型的

使用线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁地创建，销毁，实现重复利用，类似于公共工具。

好处：1、提高响应速度（减少了创建线程的时间）

2、降低资源消耗

3、便于线程管理

        corePoolSize:核心池的大小

        maxmumPoolSize:最大线程数

        keepAliveTime:线程没有任务时最多保持多长时间会终止。

●JDK 5.0起提供了线程池相关API: ExecutorService和Executors

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

➢void execute(Runnable command):执行任务1命令，没有返回值，一般用来执行

Runnable接口

➢<T> Future<T> submit(Callable<T> task): 执行任务，有返回值，一般又来执行

Callable接口

➢void shutdown():关闭连接池

package java7;


import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;

class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);//一般用的是这种方法
        
        //执行指定的线程的操作，需要提供实现runnable或者callable接口实现类的对象
        service.execute(new NumberThread());
//        service.submit()适合使用于runnable
        //关闭线程池
        service.shutdown();

    }
}


●Executors: 工具类、 线程池的工厂类，用于创建并返回不同类型的线程池

➢Executors. newCachedThreadPool():创建一个可 根据需要创建新线程的线程池

➢Executors.newFixedThreadPolln); 创建一-个可重 用固定线程数的线程池

➢Executors.newSingle ThreadExecutor():创建一-个只有 一-个线程的线程池

➢Executors.newScheduledThreadPool(n): 创建一 个线程池，它可安排在给定延迟后运

行命令或者定期地执行。

总结：

实现多线程的方式：

（1）Thread继承类

（2）runnable接口

（3）callable接口

(4)使用线程池

线程安全的解决方式：
（1）同步代码块

（2）同步方法

（3）Lock锁

重点掌握：创建方式、同步、买票问题、懒汉式、饿汉式。

小唐学姐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
方法的相关作业
CPC_JN的博客
11-12 502
方法的相关学习的题
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java - 多线程
最新发布
Achooyo的博客
09-26 109
多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）
Java高级（一）多线程（初步）
qq_51476114的博客
08-27 126
多线程 基本概念 并行与并发 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生） 线程与进程的关系 进程是程序的一次执行过程，也是系统运行程序的基本单位 线程是进程中的一个执行单元，负责当前进程中程序的执行，1个进程中至少有1个线程 一个程序运行后至少有一个进程，一个进程中可以包含多个线程 线程的调度 分时调度 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。 抢占式调度 优先让优先级高的线程使用 CPU，如...
Java硬核程序设计实验“类与对象”详解【细节满满&源码完整】
米莱虾
12-09 2333
目录 ☀️|一、实验目的 ☀️|二、实验内容 ⭐️1、编程创建一个立方体类Cube ⭐️2、设计并实现一个课程类，代表学校中的一门课程... ⭐️3、设计并实现一个“信电工程学院学生通信录”系统 ☀️|三、实验源代码 ❥1.源代码： ❥2.源代码： ❥3.源代码： ☀️|四、实验总结 ☀️|一、实验目的 1.掌握类的定义和使用、对象的声明和创建； 2.理解构造方法的作用，掌握构造方法定义和使用； 3.理解类变量与实例变量，类方法与实例方法的区别； 4.掌握包的概念与使...
Zookeeper从入门到实战（附企业面试题）
m0_46377295的博客
12-04 406
1.概述 Zookeeper是一个开源的分布式的，为分布式应用提供协调服务的Apache项目。 Zookeeper从设计模式角度来理解，是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生了变化，Zookeeper就负责通知已经在Zookeeper上注册的那些观察者做出相应的反应. Zookeeper = 文件系统 + 通知机制 1.1 工作机制 1.2 特点 1.3 数据结构 ZK中的数据保存的格式（树状结构） 注意：ZK中没有
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
Java面向对象（1）
心态的博客
04-24 7811
Java面向对象（1） 简单易懂。一起来学习吧！！！
Java学习之面向对象一-----创建学生类并在main函数中实例化学学生对象
Daycym的博客
10-08 7162
类与对象的概念 对象：真实存在的单个的个体 类：类型/类别，一类个体 例如：人类就是一个类，我们每个人都是一个对象。 再如：学生类，每个学生就是一个对象，张三是学生类的一个对象，李四也是。 类中可以包含： 所有对象所共有的特征/属性—–成员变量 所有对象所共有的行为（动）—-方法 每个学生都有姓名，学号，班级等共同属性 每个学生都有吃饭、睡觉、上课等行为 一个类可以创建多个对象 同一个类的多
java测试类 main方法_Java使用agent实现main方法之前的实例详解
weixin_30582953的博客
02-16 415
Java使用agent实现main方法之前的实例详解创建Agent项目PreMainExecutor 类，在main方法之前执行此方法public class PreMainExecutor {public static void premain(String agentOps,Instrumentation inst){System.out.println("premain execute......
4.第三单元任务三实训：编写一个类ExceptionTest，在main方法中使用try-catch-finally语句结构实现：在try语句块中，编写两个数相除操作，相除的两个操作数要求程序运行时用
热门推荐
Pre_wen
07-21 1万+
4.第三单元任务三实训：编写一个类ExceptionTest，在main方法中使用try-catch-finally语句结构实现：在try语句块中，编写两个数相除操作，相除的两个操作数要求程序运行时用户输入；在catch语句块中，捕获被0除所产生的异常，并输出异常信息；在finally语句块中，输出语句"异常处理"。 import java.util.Scanner; public cl
java 主类 测试类_Java程序编写 在类TestString的主方法中创建String类对象s(Hello
weixin_32329555的博客
02-16 644
package shiyan;import java.awt.*;import java.sql.*;import javax.swing.*;public class DB extends JFrame{privateJTextArea jta= new JTextArea();private String url="jdbc:sqlserver://127.0.0.1;Databas...
初步理解线程
wenqi1的博客
05-19 99
一个应用程序我们称为一个进程，一个进程里面可以包含很多线程 1、MyRun.java public class MyRun implements Runnable{ @Override public void run() { while (true){ try { Thread.sleep(1000); } catch (InterruptedException e) {
【java基础】 08 多线程
strange_aa的博客
02-09 154
目录 8.1 基本概念：程序、进程、线程 1 基本概念 2 多线程优点 3 何时需要多线程 8.2 线程的创建和使用 1 创建方式一：继承于Thread类 2 线程调度 3 创建方式二：实现Runnable接口 8.3 线程的生命周期 1 线程的状态 8.4 线程的同步 1 问题的提出 2 解决 3 单例模式懒汉式改为线程安全的 4 死锁 5 新增线程安全问题解决方法：锁 （方式三） 8.5 线程的通信 8.6 jdk5.0新增线程创建方式 1 实现Callable..
java学习笔记 窗口售票问题 - 线程同步机制
qq_43596503的博客
10-21 333
问题描述： 创建3个窗口卖票，票数为100张。 使用继承Thread类的方式实现，存在线程安全问题，待解决： class Window extends Thread{ private static int ticket = 100; @Override public void run() { while(true){ if(ticket > 0){ System.out.println.
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值