核心类库——多线程

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量144 收藏
点赞数
分类专栏： java学习路线 # 核心类库 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YuanLuo0911/article/details/121010958
版权

一、多线程

1 线程与进程

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程 :

  • 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程

  • 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

  • 所有的线程都拥有自己的栈空间，共用一份堆内存

2 线程调度

1. 分时调度 ：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

2. 抢占式调度：

  • 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

  • CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

3 同步与异步

同步：排队执行 , 效率低但是安全.

异步：同时执行 , 效率高但是数据不安全

4 并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

5 启动线程

5.1 继承Thread类

通过继承Thread类来创建并启动多线程步骤如下：

  • 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务。因此把run方法称为线程执行体。

  • 创建Thread子类的实例，即创建了线程对象。

  • 调用线程对象的start()方法来启动该线程。

示例代码：


public class MyThread extends Thread{
    /**
     * run方法就是线程执行的任务方法
     */
    @Override
    public void run(){
        //调用thread对象的start()可以启动任务，并触发以下的执行路径
        for (int i = 0;i < 10;i++){
            System.out.println("MyThread" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();//启动线程
        for (int i = 0;i < 10;i++){
            System.out.println("主线程"+i);
        }
    }
}

运行结果：
主方法0
MyThread0
主方法1
MyThread1
MyThread2
MyThread3
MyThread4
MyThread5
MyThread6
MyThread7
MyThread8
MyThread9
主方法2
主方法3
主方法4
主方法5
主方法6
主方法7
主方法8
主方法9

因java使用的是抢占式调度，所以上述代码每次运行的结果可能不一致。

执行流程图如下：
在这里插入图片描述

5.2 实现Runnable接口

实现Runnable接口创建并启动多线程的步骤如下：

  • 定义Runnable接口的实现类，并重写该接口的run方法，该run方法的方法体同样是该线程的线程执行体

  • 创建Runnable实现类的实例对象，并以此实例对象作为Thread的target来创建Thread类，该Thread对象才是真正的线程对象。

  • 调用线程对象的start()方法来启动该线程。

示例代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0;i < 5;i++){
            System.out.println("MyThread" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
        for (int i = 0;i < 5;i++){
            System.out.println("主方法"+i);
        }
    }
}

实现Runnable与Thread相比有如下优势：

  1. 通过创建任务，然后给线程分配的方式来实现的多线程， 适合多个相同的程序代码的线程去处理统一资源的情况
  2. 可以避免单继承所带来的局限性
  3. 任务与线程本身是分离的，提高了程序的健壮性， 代码可以多个线程共享

5.3 匿名内部类

匿名内部类本质上也是一个类实现了Thread或者Runnable接口，重写了run方法，只不过这个类没有名字，直接作为参数传入Thread类，示例代码：

public class Demo {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run(){
                for (int i = 0;i < 10;i++){
                    System.out.println("MyThread" + i);
                }
            }
        }.start();
        for (int i = 0;i < 10;i++){
            System.out.println("主方法"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
       new Thread(new Runnable() {
			public void run() {
				 for (int i = 0;i < 10;i++){
                    System.out.println("MyThread" + i);
                }
			}
		}).start();
        for (int i = 0;i < 10;i++){
            System.out.println("主方法"+i);
        }
    }
}

6 常用方法

获取线程名称：Thread.currentThread().getName()

设置线程名称：Thread.setName(“新名称”)

线程休眠：Thread.sleep()

线程阻塞：Thread.interrupt()

守护线程：Thread.setDaemon(true) ------一定要在线程启动前设置

  • 线程分为守护线程与用户i西安城
  • 用户线程：当一个进程不包含任何的存活用户线程时，进行结束
  • 守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡

7 线程安全与线程不安全

7.1 线程安全

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

7.2 线程不安全

线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据 。

线程不安全例子：

  public class Demo2 {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //票数
        private int count = 5;
        @Override
        public void run() {
            while(true){
                if(count>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //卖票
                    System.out.println("正在出票...");
                    count--;
                    System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);
                }
            }
        }
    }
}
运行结果：
    正在出票...
    正在出票...
    Thread-1出票成功，余票为：3
    正在出票...
    Thread-1出票成功，余票为：2
    正在出票...
    Thread-1出票成功，余票为：1
    正在出票...
    正在出票...
    Thread-2出票成功，余票为：-1
    Thread-1出票成功，余票为：0
    Thread-0出票成功，余票为：4

运行结果明显不符合正常逻辑

7.3 如何保证线程安全

  1. 同步代码块

    synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

    格式:

    synchronized(同步锁){
	需要同步操作的代码
}

    static class Ticket implements Runnable{
    //票数
    private int count = 5;
    Object lock = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (lock){
                if(count>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //卖票
                    System.out.println("正在出票...");
                    count--;
                    System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);
                }
            }

        }
    }

    运行结果：

    正在出票...
Thread-2出票成功，余票为：4
正在出票...
Thread-2出票成功，余票为：3
正在出票...
Thread-2出票成功，余票为：2
正在出票...
Thread-2出票成功，余票为：1
正在出票...
Thread-2出票成功，余票为：0

    1. 同步方法

      使用synchronized修饰的方法,就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

      格式：

      public synchronized void method(){
	可能会产生线程安全问题的代码 
}

      
static class Ticket implements Runnable{
    //票数
    private int count = 5;
    Object lock = new Object();
    @Override
    public void run() {
        while(true){
            boolean flag = sale();
            if (!flag){
                break;
            }
        }
    }

    public synchronized boolean sale(){
        if(count>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卖票
            System.out.println("正在出票...");
            count--;
            System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);
            return true;
        }else{
            return false;
        }
    }
}

      运行结果:

      正在出票...
Thread-2出票成功，余票为：4
正在出票...
Thread-2出票成功，余票为：3
正在出票...
Thread-2出票成功，余票为：2
正在出票...
Thread-2出票成功，余票为：1
正在出票...
Thread-2出票成功，余票为：0

    2. Lock锁

      java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

      Lock锁也称同步锁，加锁与释放锁方法如下：

      public void lock() :加同步锁。

      public void unlock() :释放同步锁。

      static class Ticket implements Runnable{
    //票数
    private int count = 5;
    //显示锁
    private Lock l = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            l.lock();
            if(count>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //卖票
                System.out.println("正在出票...");
                count--;
                System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);

            }else{
                break;
            }
            l.unlock();
        }
    }
}

8 线程死锁（DeadLock）

8.1 死锁概述

线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。

8.2 死锁产生的条件

  • 互斥条件：一个资源，或者说一个锁只能被一个线程所占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其它线程均是无法获取到这个锁的。
  • 占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
  • 不可剥夺条件：任何一个线程都无法强制获取别的线程已经占有的锁。
  • 循环等待条件：线程A拿着线程B的锁，线程B拿着线程A的锁。

死锁演示：

public class Demo04 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }
    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        public MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }
        @Override
        public void run() {
            p.say(c);
        }
    }
    //罪犯
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
        }
        public synchronized void fun(){
            System.out.println("罪犯被放走了，罪犯也放了人质");
        }
    }
    //罪犯
    static class Police {
        public synchronized void say(Culprit c) {
            System.out.println("警察：你放了人质，我放了你");
        }

        public synchronized void fun() {
            System.out.println("警察救了人质，但罪犯逃了");
        }
    }
}

运行结果

罪犯：你放了我，我放了人质
警察：你放了人质，我放了你

这样便造成了死锁，p.say()与c.say()都想拿着对方

8.3 如何避免死锁

  • 加锁顺序：线程按照相同的顺序加锁。
  • 加锁时限，线程获取锁的过程中限制一定的时间，如果给定时间内获取不到，就算了，别勉强自己。这需要用到Lock的一些API。

8.4 死锁检测

在发生死锁之后，程序就卡住了没有任何反应，但程序仍在运行，因此需要借助一些

  • 首先使用 jps -l 显示正在运行的虚拟机进程，并显示虚拟机执行主类(main函数所在的类)名称以及这些进程的本地虚拟机唯一ID
  • 使用 jstack + id 进行跟踪排查

9 线程的状态

Java中线程的状态分为6种。

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
    线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  3. 阻塞(BLOCKED)：表示线程阻塞于锁。
  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
  5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  6. 终止(TERMINATED)：表示该线程已经执行完毕。

在这里插入图片描述

二、Callable

面试有人会问：线程的实现方式有几种？

很多人可能回答：2种，继承Thread类，实现Runnable接口。

很多忽略了callable这种方式。

也许有人知道callable，也知道callable和Runnable的区别是callable可以有返回值，也可以抛出异常的特性，而Runnable没有。

注意callable可以有返回值，也可以抛出异常这点很关键。

Callable使用步骤

  1. 编写类实现Callable接口 , 实现call方法

    class XXX implements Callable<T> { 
    @Override 
    public <T> call() throws Exception { 
        return T; 
    } 
}

  2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象

    FutureTask<Integer> future = new FutureTask<>(callable);

  3. 通过Thread,启动线程

    new Thread(future).start();

Runnable 与 Callable 接口定义

//接口定义 
//Callable接口 
public interface Callable<V> { 
    V call() throws Exception;
}
//Runnable接口 
public interface Runnable { 
    public abstract void run(); 
}

Runnable 与Callable的相同点

  • 都是接口

  • 都可以编写多线程程序

  • 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

  • Runnable没有返回值；Callable可以返回执行结果

  • Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执

行，如果不调用不会阻塞。

三、线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间。线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

  • 降低资源消耗。

  • 提高响应速度。

  • 提高线程的可管理性。

1 线程池类型 ExecutorService

1.1 缓存线程池

/**
* 缓存线程池. 
* (长度无限制) 
* 执行流程: 
* 	1. 判断线程池是否存在空闲线程 
* 	2. 存在则使用 
* 	3. 不存在,则创建线程 并放入线程池, 然后使用 
*/ 
ExecutorService service = Executors.newCachedThreadPool(); 
//向线程池中 加入 新的任务 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
});

1.2 定长线程池

/**
* 定长线程池. 
* (长度是指定的数值) 
* 执行流程:
*	 1. 判断线程池是否存在空闲线程 
*	 2. 存在则使用 
*	 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
* 	4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 */ 
ExecutorService service = Executors.newFixedThreadPool(2); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
});

1.3 单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.

/**
* 单线程线程池. 
* 执行流程: 
* 1. 判断线程池的那个线程是否空闲 
* 2. 空闲则使用 
* 3. 不空闲,则等待 池中的单个线程空闲后 使用
*/ 
ExecutorService service = Executors.newSingleThreadExecutor(); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
});
service.execute(new Runnable() { 
    @Override
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    } 
});

1.4 周期性任务定长线程池

public static void main(String[] args) { 
    /**
    * 周期任务 定长线程池. 
    * 执行流程: 
    * 1. 判断线程池是否存在空闲线程 
    * 2. 存在则使用 
    * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
    * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
    *
    * 周期性任务执行时: 
    * 定时执行, 当某个时机触发时, 自动执行某任务 .
    */
    ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
    /**
    * 定时执行 
    * 参数1. runnable类型的任务 
    * 参数2. 时长数字 
    * 参数3. 时长数字的单位 
    */ 
    /*service.schedule(new Runnable() { 
    	@Override 
    	public void run() { 
    		System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
   		} 
   	},5,TimeUnit.SECONDS); 
   	*/
    /**
    * 周期执行 
    * 参数1. runnable类型的任务 
    * 参数2. 时长数字(延迟执行的时长) 
    * 参数3. 周期时长(每次执行的间隔时间) 
    * 参数4. 时长数字的单位 
    */ 
    service.scheduleAtFixedRate(new Runnable() { 
        @Override 
        public void run() { 
            System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
        } 
    },5,2,TimeUnit.SECONDS); 
}
芒果不是芒
关注
专栏目录
多线程——线程安全及实现机制
qq_42583242的博客
08-23 679
多线程——线程安全及实现机制 文章目录多线程——线程安全及实现机制一、线程安全概念二、Java 语言中的线程安全1、不可变2、绝对线程安全3、相对线程安全（重要）4、线程兼容三、线程安全的实现机制1、互斥同步(Synchronized、Reentrantlock)2、非阻塞同步(CAS、原子类)3、无同步方案（ThreadLocal）四、总结 一、线程安全概念 讨论线程安全，需要以多个线程之间存在共享数据访问为前提。因为如果根本不存在多线程，又或者一段代码根本不会与其他线程共享数据，那么从线程安全的角度来看
12-多线程（核心类库）
weixin_42688085的博客
12-16 804
感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100） Java基础思维导图，完整Java体系的链接 一，多线程概况 1.1多线程出现的前提？     我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏 边听歌，怎么设计？要解决上述问题，得使用多进程或者多线程来解决。 1.2线程与进程     进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间  &nbsp
多线程以及pthread线程库的使用
欧特GO
11-26 2302
一.什么是线程         线程是 CPU 调度的最小执行单位，你可以创建一个线程用于 ListenMusic，再创建一个线程去 PlayGame，这样操作系统就是同时处理这两个任务的（并发）。 二.pthread库 (1) 使用说明         POSIX 标准定义了一套线程操作相关的......
Java核心类库之（多线程：实现多线程、线程同步）
努力让自己发光，对的人才能迎着光而来
07-27 1万+
1 多线程 1.1 进程 1.2 线程 1.3 多线程的实现方式 1.3.1 方式1：继承Tread类 1.3.2 方式2：实现Runnable接口 1.3.3 方式3：实现Callable接口 1.4 设置和获取线程名称 1.5 线程调度 1.6 线程控...
java常用类库——concurrent包
码农@攻城狮
07-14 760
文章目录concurrent包线程类型线程生命周期线程池创建线程池Executor & ExecutorServiceinterface ScheduledExecutorServiceinterface ThreadFactoryclass Executorsclass CountDownLatchinterface Future自定义线程池Java中的Threa...
Guava类库——BiMap和Multimap详解
西凉的悲伤博客
08-18 2197
Guava 是一套来自 Google 的核心 Java 库，其中包括新的集合类型、不可变的集合、图库，以及并发、I/O、散列、缓存、基元、字符串等实用工具！它更细粒度的提供了一些jdk没有的api和优化了一些操作，可以让你的代码更加优雅简洁高效。它被广泛用于 Google 内部的大多数 Java 项目，也被许多其他公司广泛使用。它被广泛用于 Google 内部的大多数 Java 项目，也被许多其他公司广泛使用。......
Java核心类库篇4——集合
qq_43842093的博客
09-04 166
Java核心类库篇4——集合 1、集合的意义 记录单个数据内容时，则声明一个变量 记录多个类型相同的数据内容时，声明一个一维数组 记录多个类型不同的数据内容时，则创建一个对象 记录多个类型相同的对象数据时，创建一个对象数组 记录多个类型不同的对象数据时，则准备一个集合 2、集合的分类 单列集合（Collection） 双列集合（Map） 3、Iterator接口 java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素 java.util.Co
JAVA——多线程详解
qq_45871067的博客
12-27 707
JAVA——多线程详解（Java.Thread） 文章目录JAVA——多线程详解（Java.Thread）一、进程（Process）与线程（Thread）二、核心概念三、线程的创建1、继承Thread类2、实现Runnable接口3.并发问题4.实现Callable接口（了解）四、静态代理五、Lamda表达式六、线程停止七、线程休眠八、线程礼让——yield九、线程强制执行——Join十、观测线程状态十一、线程的优先级——Priority十二、守护（daemon）线程十三、线程同步机制十四、三大不安全案例十
好用的Java工具类库—— Hutool
热门推荐
Javaの甘乃迪的博客
10-10 3万+
好用的Java工具类库—— Hutool
【Java】—— 多线程：相关概念、创建和启动线程
weixin_63106307的博客
09-21 1078
Java语言的JVM允许程序运行多个线程，使用类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Thread类的特性每个线程都是通过某个特定Thread对象的run()方法来完成操作的，因此把run()方法体称为线程执行体。通过该Thread对象的start()方法来启动这个线程，而非直接调用run()要想实现多线程，必须在主线程中创建新的线程对象。
03夯实基础之java核心类库
小白的Soda的博客
12-12 1724
文章目录夯实基础之java核心类库一、Java核心类1.1 泛型1.1.1 定义1.1.2 泛型类1.1.3 泛型接口1.1.4 泛型方法1.1.5 泛型限制类型1.1.6泛型中通配符 ？的使用1.1.7 泛型的作用1.1.8 注意1.2 JDK 中所有类的基类—— Object 类1.2.1 Java.lang 包下的类不需要手动导入1.2.2 类构造器1.2.3 equals 方法1.2.4 getClass 方法1.2.5 hashCode 方法1.2.5.1 什么是 hashCode()1.2.5.
Java类库复习——java.lang.String
04-04
这个类位于核心类库中，因此无需显式导入即可使用。本文将深入探讨`String`类的一些关键知识点，包括它的特性、构造方法、常用方法以及在实际开发中的应用。 首先，`String`对象表示不可变的字符序列。这意味着一旦...
CThreadBase超级多线程类库
05-25
类库还包含了示例代码——GDI例子，演示了如何在多线程环境中使用Graphics Device Interface (GDI) 进行图形绘制。这展示了CThreadBase在实际应用中的能力，比如在UI更新或者后台计算等场景下，多线程的使用可以提高...
MFC基础类库详解——中文msdn
08-13
8. **线程支持**：MFC提供了CWinThread类来处理多线程编程，使得开发者可以在一个应用程序中实现并行任务。 学习MFC时，需要理解Windows消息机制，熟悉C++面向对象编程，以及掌握基本的Windows API知识。"MFC基础...
Servlet的生命周期
最新发布
wyk的博客
11-13 834
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 246
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
kequanrrr的博客
11-12 365
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 662
Rest请求处理
JAVA学习接口案例实例
shangan_3的博客
11-08 236
【代码】JAVA学习接口案例实例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值