Java学习笔记-多线程

最新推荐文章于 2024-08-19 16:01:20 发布
最新推荐文章于 2024-08-19 16:01:20 发布
阅读量118 收藏
点赞数
分类专栏： Java基础 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljb0077/article/details/117002558
版权

文章目录

多线程基本概念

并发与并行

  • 并发: 指两个或多个事件在同一个时间段内发生。
  • 并行: 指两个或多个事件在同-时刻发生(同时发生)。

线程与进程

基本概念

首先要理解进程(Processor)和线程(Thread)的区别

  • 进程: 是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间, -一个应用程序可以同时运行多个进程;进程也是程序的一-次执行过程,是系统运行程序的基本单位;系统运行一一个程序即是-个进程从创建、运行到消亡的过程。如启动一个QQ.exe就叫一个进程。 接着又启动一个WeiXin.exe，这叫两个进程。
  • 线程: 线程是进程中的一个执行单元,负责当前进程中程序的执行, 一个进程中至少有一个线程。 一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。线程是在进程内部同时做的事情，比如在迅雷里，有很多资源要同时下载

简而言之:一个程序运行后至少有一一个进程 , -一个进程中可以包含多个线程

线程调度

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

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

Thread类

构造方法

  • Thread() 分配一个新的 Thread对象。
  • Thread(String name) 分配一个指定名称的新的 Thread对象。
  • Thread(Runnable target) 分配一个带有指定目标新的 Thread对象。
  • Thread(Runnable target, String name) 分配一个带有指定目标新的线程对象，并指定名字。

常用方法

  • String getName() 返回此线程的名称。
  • void setName(String name) 将此线程的名称更改为等于参数 name 。
  • void start() 导致此线程开始执行，Java虚拟机调用此线程的run方法。
  • void run() 如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。
  • static void sleep(long millis) 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），
  • static Thread currentThread() 返回对当前正在执行的线程对象的引用。

创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务。实际上就是执行一-段程 序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。
Java中通过继承Thread类来创建并启动多线程的步骤如下:

方法1：将一个类声明为Thread的子类

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把 run() 方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的 start() 方法来启动该线程
public static void main(String[] args){
    // 创建自定义线程对象
    MyThread mt = new MyThread("新的线程");
    // 调用start()方法，开启新线程，自动执行run()方法
    mt.start();		// 如果调用的是mt.run()，就不是多线程了，就是平常的一般方法调用。
    // 在主方法中执行for循环
    for(int i = 0; i < 10 ; i++){
        String name = Thread.currentThread().getName();	// 获取当前线程的名称
        System.out.println(name + "线程-No" + i);
    }
}

// MyThread类
public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // String name = getName();    // 获取该线程的名称,方法1
            // 获取线程名，方法2
            Thread thread = Thread.currentThread();
            String name = thread.getName();
            System.out.println(name + "线程-No" + i);
        }
    }
}

方法2：创建一个线程是声明实现类Runnable接口

第一种方法会有一个缺点，因为在Java中类是单继承的，如果继承了Thread类，就无法再继承其他的类，所以可以通过实现Runnable接口进行。

java.lang.Runnable：接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

实现步骤：

  1. 创建一个Runnable接口的实现类。
  2. 在实现类中重写Runnable接口的run()方法，设置线程任务
  3. 创建一个Runnable接口的实现类对象
  4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
  5. 调用Thread类中start() 方法，会自动开启新的线程执行run()方法
public static void main(String[] args) {
    // 3 创建一个`Runnable`接口的实现类对象
    RunnableImpl rni = new RunnableImpl();
    // 4 创建`Thread`类对象，构造方法中传递`Runnable`接口的实现类对象
    Thread thread = new Thread(rni);
    // 5 调用`Thread`类中`start()` 方法，会自动开启新的线程执行`run()`方法
    thread.start();
}

// RunnableImpl.java

// 1 创建一个`Runnable`接口的实现类
public class RunnableImpl implements Runnable{
    // 2 在实现类中重写`Runnable`接口的`run()`方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

实现Runnable接口创建多线程的好处

  1. 适合多个相同的程序代码的线程去共享同一个资源。

  2. 可以避免Java中的单继承的局限性。一个类只能继承一个类，继承了Thread就不能继承其他的类了。

  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

    实现Runnable接口的方式，把设置线程任务和开启线程任务进行了分离（解耦）

    ​ 实现类中，重写了run方法：用来设置线程任务

    ​ 创建Thread类对象调用start方法用来开启新线程

  4. 线程池只能放入实现Runnable或Collable类线程，不能直接放入继承Thread的类。

匿名内部类方式创建线程

匿名：没有名字
内部类：写在其他类内部的类
匿名内部类作用：简化代码
把子类继承父类，重写父类的方法，创建子类对象合一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类实现类对象，而这个类没有名字
格式:
new 父类/接口(){
重复父类/接口中的方法
};

public static void main(String[] args) {
    // 方法一：线程父类是Thread
    new Thread(){
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("法1：" + Thread.currentThread().getName() + "--->" + i);
            }
        }
    }.start();

    // 方法二：线程是接口Runnable的实现类
    Runnable rn = new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("法2：" + Thread.currentThread().getName() + "--->" + i);
            }
        }
    };
    new Thread(rn).start();

    // 方法二简化版
    new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                System.out.println("法2简化版：" + Thread.currentThread().getName() + "--->" + i);
            }
        }
    }).start();
}

线程安全

问题的出现

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，说明线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是“菊花侠大战桃花怪”，本次电影的座位共100个。有两个窗口正在卖同一张第21号座的票。

代码示例：

// RunnableImpl.java
public class RunnableImpl implements Runnable{
    // 定义一个多个线程共享的票源
    private int ticket = 100;
    @Override
    public void run() {
        // 目的是把票卖完。
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "--> 正在卖票第" + ticket + "张票");
                ticket -- ;
            }
        }
    }
}

public static void main(String[] args) {
    RunnableImpl rni = new RunnableImpl();
    Thread t1 = new Thread(rni);    // 卖票窗口1
    Thread t2 = new Thread(rni);    // 卖票窗口1
    Thread t3 = new Thread(rni);    // 卖票窗口1

    // 三个窗口同时开始卖票
    t1.start();
    t2.start();
    t3.start();
}

结果可能会出现以下问题：

  • 有多个窗口正在卖同一张票
  • 出现不存在的票号，如0，-1等。

问题的解决-线程同步

法1：同步代码块

解决线程安全问题的一种方案：使用同步代码块
格式：

synchronized(锁对象){
	可能会出现线程安全问题的代码(如访问了共享数据的代码)
}

注意:

  1. 通过代码块中的锁对象，可以使用任意的对象
  2. 但是必须保证多个线程使用的锁对象是同一个
  3. 锁对象作用：把同步代码块锁住,只让一个线程在同步代码块中执行

卖票案例的代码示例：

// 采用同步代码块 对RunnableImpl.java代码修改如下
public class RunnableImpl implements Runnable{
    private int ticket = 100;

    // 创建一个锁对象，比如用Object对象
    Object obj = new Object();

    @Override
    public void run() {
        while(true){
            synchronized (obj){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "--> 正在卖票第" + ticket + "张票");
                    ticket -- ;
                }
            }
        }
    }
}

法2：同步方法

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

格式：

修饰符 synchronized 返回值类型 myMethod(){
	可能会出现线程安全问题的代码(如访问了共享数据的代码)
}

使用步骤：

  1. 把访问了共享数据的代码抽取出来，放到一个方法中
  2. 在方法声明时添加synchronized修饰符
// 采用同步方法 对RunnableImpl.java代码修改如下
public class RunnableImpl implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            payTicket();
        }
    }
    // 同步方法解决线程安全问题
    public synchronized void payTicket(){
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName() + "--> 正在卖票第" + ticket + "张票");
            ticket -- ;
        }
    }
}

法3：Lock锁

java.util.concurrent.locks.Lock：机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下:

  • public void lock() ：加同步锁。
  • public void unlock()：释放同步锁。

使用步骤：

  1. 在成员位置创建一个ReentrantLock对象
  2. 在可能会出现安全问题的代码前调用Lock接口的lock()获取锁方法
  3. 在可能会出现安全问题的代码后调用Lock接口的unlock()释放锁方法

使用如下：

// 采用Lock方法 对RunnableImpl.java代码修改如下
public class RunnableImpl implements Runnable{
    private int ticket = 100;

    // 1 在成员位置创建一个ReentrantLock对象
    Lock myLock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            // 2 在可能会出现安全问题的代码前调用Lock接口的`lock()`获取锁方法
            myLock.lock();
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "--> 正在卖票第" + ticket + "张票");
                ticket -- ;
            }
            // 3 在可能会出现安全问题的代码后调用Lock接口的`unlock()`释放锁方法
            myLock.unlock();
        }
    }
}

最好加上try…catch…finally代码块，能保证无论是否出现异常，都会把Lock释放掉。示例如下

while(true){
    // 2 在可能会出现安全问题的代码前调用Lock接口的`lock()`获取锁方法
    myLock.lock();
    if(ticket > 0){
        try {
            System.out.println(Thread.currentThread().getName() + "--> 正在卖票第" + ticket + "张票");
            ticket -- ;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 3 在可能会出现安全问题的代码后调用Lock接口的`unlock()`释放锁方法
            myLock.unlock();
        }
    }
}

线程状态

概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：
这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

  • NEW：至今尚未启动的线程处于这种状态。
  • RUNNABLE：正在 Java 虚拟机中执行的线程处于这种状态。
  • BLOCKED：受阻塞并等待某个监视器锁的线程处于这种状态。
  • WAITING：无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
  • TIMED_WAITING：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
  • TERMINATED：已退出的线程处于这种状态。

在给定时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所有操作系统线程状态。

在这里插入图片描述

等待与唤醒案例

说明：顾客和老板线程，顾客下单后，老板开始做，做好了通知顾客

public static void main(String[] args) {
    // 创建锁对象，保证唯一
    Object obj = new Object();
    // 创建一个消费者线程
    new Thread(){
        @Override
        public void run() {
            while(true){
                synchronized (obj){
                    System.out.println("告知老板要的奶茶种类和数量！");
                    try {
                        // 调用wait方法，放弃CPU进入WAITING状态，
                        // wait()方法里面可以有参数，参数是最长等待时间毫秒，如`obj.wait(3000);` 指3秒后若还未被唤醒，则自动唤醒，【若无参数的话，只有被唤醒时才会醒。】
                        obj.wait(); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("奶茶做好了，开喝。");
                    System.out.println("-------------------------");
                }
            }
        }
    }.start();

    // 创建一个老板类
    new Thread(){
        @Override
        public void run() {
            while (true){
                try {
                    Thread.sleep(3000); // 花3秒钟做奶茶
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj){
                    System.out.println("老板3秒钟做好了奶茶，告知顾客可以喝了");
                    obj.notify();// 调用notify方法，可随机唤醒一个WAITING状态的线程
                    // 还有`obj.notifyAll();`方法，用于唤醒所有WAITING状态的线程
                }
            }
        }
    }.start();
}

等待唤醒机制

线程间通信

概念：多个线程在处理同一资源，但处理的动作（线程的任务）却不相同。

比如：线程A用来做奶茶，线程B用来喝奶茶，奶茶可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A和线程B之间就存在线程通信问题

为什么要处理线程键通信？

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即为等待唤醒机制。

等待幻想机制

什么是等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争( race) ，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

就是在一个线程进行了规定操作后，就进入等待状态( wait())，等待其他线程执行完他们的指定代码过后再将其唤醒( notify() ) ；在有多个线程进行等待时，如果需要，可以使用notifyAll()来唤醒所有的等待线程。

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的,使用到的3个方法的含义如下:

  1. wait：线程不再活动，不再参与调度，进入waitset中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程状态即是WAITING。它还要等着别的线程执行一个特别的动作，也即是"通知( notify )”在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列( ready queue )中

  2. notify：则选取所通知对象的wait set中的一个线程释放；例如,餐馆有空位置后,等候就餐最久的顾客最先入座。

  3. notifyAll：则释放所通知对象的wait set上的全部线程。

调用wait和notify方法需要注意的细节

  1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同-一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象,而任意对象的所属类都是继承了0bject类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

生产者与消费者问题

线程池

思想作用概述

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题:

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束 了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用 ，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务?
在Java中可以通过线程池来达到这样的效果。

线程池概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。由于线程池中有很多操作都是与优化资源相关的，我们在这里就不多螯述。我们通过一-张图来了解线程池的工作原理:

在这里插入图片描述

合理利用线程池能够带来三个好处:

  1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
  2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

线程池的使用

线程池：JDK1.5之后提供的。java.util.concurrent.Executors：线程池的工厂类，用来生成线程池。
Executors类中的静态方法:

  • static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
    参数:
    int nThreads：创建线程池中包含的线程数量
    返回值:
    ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收(面向接口编程)

java.util.concurrent.ExecutorService：线程池接口

  • 用来从线程池中获取线程,调用start方法,执行线程任务
    submit(Runnable task) 提交一个Runnable 任务用于执行
    关闭/销毁线程池的方法
    void shutdown()
    线程池的使用步骤:
    1. 使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
    2. 创建一个类,实现Runnable接口,重写run方法，设置线程任务
    3. 调用ExecutorService中的方法submit，传递线程任务(实现类)，开启线程,执行run方法
    4. 调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

代码示例

public static void main(String[] args) {
    // 1 使用线程池的工厂类`Executors`里边提供的静态方法`newFixedThreadPool`生产一个指定线程数量的线程池
    ExecutorService es = Executors.newFixedThreadPool(2);   // 该线程池只能放两个线程
    // 3 调用`ExecutorService`中的方法`submit`，传递线程任务(实现类)，开启线程,执行`run`方法
    es.submit(new RunnableImpl());
    es.submit(new RunnableImpl());
    es.submit(new RunnableImpl());

    // 4 调用`ExecutorService`中的方法`shutdown`销毁线程池(不建议执行)
    es.shutdown();
}

// RunnableImpl.java
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了一个新的线程执行");
    }
}

执行结果：

pool-1-thread-1创建了一个新的线程执行
pool-1-thread-2创建了一个新的线程执行
pool-1-thread-1创建了一个新的线程执行
正午12:00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
狂神说Java学习笔记-GUI
07-17
【Java GUI】(图形用户界面，Graphical User Interface)是Java编程中不可或缺的一部分，...对于初学者来说，"狂神说Java学习笔记"将是一个宝贵的资源，其中包含的源代码和图片能够直观地展示如何将理论转化为实际应用。
JAVA并发编程实践-线程安全-学习笔记
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
零基础Java入门课程-多线程
07-01
在IT行业中，Java是一种广泛应用的编程语言，尤其在企业级...文档"零基础Java入门课程-多线程-20201217202008101.docx"很可能是课程的详细讲义或笔记，包含了上述知识点的详细解释和实例，建议仔细研读，以加深理解。
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 130
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
JAVA进阶补充
2301_80150315的博客
08-15 981
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 870
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
Java基础之原反补码
u012135697的博客
08-14 510
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
【Spring框架】
m0_71941456的博客
08-18 650
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 408
【代码】springboot网上商品订单转手系统bootpf
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 436
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 1067
【代码】springboot旅游网站
总结常见报错信息
m0_68903702的博客
08-16 323
在@Controller注解中，返回的是字符串或者是字符串匹配的模板名称，即直接渲染视图，与html页面配合使用的，java后端的代码要结合html的情况进行渲染,使用model对象（或者modelandview）的数据将填充user视图中的相关属性，然后展示到浏览器；而在@RestController中，返回的应该是一个对象，即return一个user对象，这时，在没有页面的情况下，也能看到返回的是一个user对象对应的json字符串。情形一：若前端传入Json格式，后端使用。
基于vue框架的爱看电影网站v4o92（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-15 1003
项目功能：用户,电影分类,电影信息,电影评分基于Vue框架的爱看电影网站项目功能丰富多样，旨在为用户提供一个集电影浏览、信息查询、观影体验、互动交流于一体的综合性平台。
在Java项目中集成Jackson JSON和YAML处理库
2301_77695569的博客
08-14 690
本文将指导您如何在Java项目中集成Jackson库，用于处理JSON和YAML数据格式。通过Maven依赖配置，我们将探索如何使用进行JSON的序列化和反序列化，以及如何使用yamlMapper处理YAML格式的数据。介绍如何通过注解和配置来自定义序列化和反序列化的行为。
Linux环境下运行介绍
shiwei0813的博客
08-14 407
如果在Linux系统下学习C语言，就会了解到两套文件编程接口函数：C语言标准的文件编程函数:fopenfreadfwritefcloseLinux下提供的文件编程函数:openreadwriteclose基于文件指针: fopen fclose fread fwrite 比较适合操作普通文件。基于文件描述符: open close read write 比较适合操作设备文件。
Javascript嵌套函数的调用
Cc040909的博客
08-17 704
闭包的嵌套函数就不同了，由于有两个函数，调用栈就标记为1， 表示内部还有函数，这个函数不知道什么时候才执行，所以js引擎就把他保存在内存中了。恰好第一个函数和第二个函数执行的时候，眼睛观察到的调用是看不到对象，所以执行的是默认绑定，都默认绑定在全局对象window上(浏览器环境)。上面这个总结的过程非常微妙，细节就在于嵌套的函数的分部执行过程，尽管内部函数嵌套在外部函数内，但是外部函数并没有影响内部函数的权利，内部函数的执行是不受外部函数控制的。外部函数和内部函数是两个不同的事件循环位置，独立调用的，
工作日常踩坑
08-15 129
在BaseController中 使用 spring @Resource注解引入一个service发现找不到；最终使用容器上下文工具类获取service。
Java多线程学习笔记：线程状态与同步机制
"这篇学习笔记主要探讨了多线程的概念、创建与启动方式、线程方法、线程的生命周期及状态、系统锁synchronized的使用和特性，包括可重入锁和锁升级机制。" 在Java编程中，多线程是一项重要的并发处理技术，它允许...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值