Java学习之路（八）：线程

最新推荐文章于 2022-06-02 18:14:09 发布
最新推荐文章于 2022-06-02 18:14:09 发布
阅读量142 收藏
点赞数 1
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42826747/article/details/107015483
版权

一、基本概念：程序、进程、线程

  1. 程序（program）：是为完成特定任务、用某种语言编写的一组的指令的集合。即指一段静态的代码，静态对象
  2. 进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的的过程：有它自身的产生、存在和消亡的过程——生命周期
    ① 例如：运行中的QQ，MP3
    ② 程序是静态的，进程是动态
    ③ 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
  3. 线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径
    ① 若一个进程同一时间并行多个线程，就是支持多线程的
    ② 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
    ③ 一个进程中的多个线程共享相同的内存单元/内存空间地址 --> 它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能会带来安全隐患。
  • 单核CPU和多核CPU的理解
  1. 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务，例如:虽然有多车道，但是收费站只有一一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”(晾着他， 等他想通了，准备好于钱，再去收费)。但是因为CPU时间单元特别短，因此感觉不出来。

例如： 一个Java应用程序java.exe， 其实至少有三个线程: main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

  1. 如果是多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
  • 并行与并发
  1. 并行：多个CPU同时执行多个任务。比如多个人同时做不同的事
  2. 并发：一个CPU（采用时间片）'同时’执行多个任务。比如：秒杀、多个人同时做同一件事

二、线程的创建和使用

  • 使用多线程的优点
  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
  2. 提高计算机系统CPU的利用率
  3. 改善程序结构。将即长又复杂的进程分为多个线程，独立运行，利于理解和修改
  • 何时需要多线程
  1. 程序需要同时执行两个或多个任务
  2. 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
  3. 需要一些后台运行的程序时

1.Thread类的特性

  1. 每个线程都是通过某个特定的Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
  2. 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

2.创建多线程之方式一：继承于Thread类

步骤

  1. 创建一个基础于Thread类的子类
  2. 重写Thread类的run() ——> 将此线程执行的操作声明在run()中
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()：①启动当前线程，②调用当前线程的run()
package com.zc.test.thread;

/**
 * @author ZC
 * @Description  创建多线程方式一
 * @date 2020-06-29 11:49
 */

//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) {
        //创建子类的对象
        MyThread myThread = new MyThread();
        //调用该对象的start方法：①启动当前线程，②调用当前线程的run()
        myThread.start();
        for (int i = 0;i < 100 ;i++){
            if ( i%2 == 0){
                System.out.println(i+"____——————————————————");
            }
        }
    }
}

注意：

  1. 我们不能通过直接调用run()的方式启动线程
  2. 再启动一个线程，不可以还让已经start()的线程在此start()，不然会报IllegalThreadStatu

3. Thread类的有关方法

  1. void start()：启动线程，并执行对象的run()方法
  2. run()：线程在被调度的时候执行的操作，通常子类需要重写该方法
  3. String getName()：返回线程的名字
  4. void setName(String name)：设置该线程的名字
  5. static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
  6. static void yield()：释放当前CPU的执行权
  7. final void join()：在线程a中调用线程b的join()方法，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
  8. void stop：已过时，当执行此方法时，强制结束当前线程
  9. static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行/睡眠)
    10.boolean isAlive() ： 判断当前线程是否存活

4. 线程的调度

①调度策略

  1. 时间片
  2. 抢占式：高优先级的线程抢占CPU

②Java的调度方法

  1. 同优先级的线程组成先进先出队列（先到先服务），使用时间片策略
  2. 对搞优先级，使用优先调度的抢占式策略

③线程的优先级等级

注意：高优先级的线程抢占低优先级线程的CPU的执行权，但只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行
a. MAX_PRIORITY：10
b. MIN_PRIORITY：1
c. NORM_PRIORITY：5 —> 默认优先级

④如何获取和设置当前线程的优先级

a. getPriority()：获取线程的优先级
b. setPriority(int p)：设置线程的优先级

5.创建多线程之方式二：实现Runnable接口

步骤

  1. 创建一个实现了Runable接口的实现类
  2. 实现类去实现Runable接口的抽象方法：run()
  3. 创建实现类的对象
  4. 将实现类的对象作为参数传递到Thread类的构造器中，创建一个Thread类的对象
    5.通过Thread类的对象调用start方法
package com.zc.test.thread;

/**
 * @author ZC
 * @Description 创建多线程的方式二
 * @date 2020-06-29 16:33
 */

//1.创建实现了Runable接口的实现类
class MyThread2 implements Runnable{
    
    //2.实现Runable的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"______"+i);
        }
    }
}    

public class ThreadTest3 {

    public static void main(String[] args) {
        //3.创建实现类的对象
        Runnable r = new MyThread2();
        //4.将实现类的对象作为参数传递给Thread的构造器，创建Thread类的对象
        Thread thread = new Thread(r);
        //5.调用Thread类的对象的start()：①启动线程，②调用当前线程的run()——>调用了Runable类型的target的run(0
        thread.start();
	
		//再启动一个线程
        Thread thread1 = new Thread(r);
        thread1.start();
    }
}

6.比较创建线程的两种方式

  • 开发中：优先选择：实现Runable接口的方式
  • 原因：
    1. 实现的方式没有类的单继承性的局限
    2. 实现的方式更适合来处理多个线程有共享数据的情况
  • 联系：public class Thread implements Runable
  • 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中

三、线程的生命周期

  • JDK中用Thread。State枚举类定义了线程的几种状态。（NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED）

  • 一个线程在其完整的生命周期通常要经历以下5种状态

    1. 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
    2. 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没有分配到CPU资源
    3. 运行：当就绪的线程被调度并获得CPU资源时，并进入运行状态，run()方法定义了线程的操作和功能
    4. 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
    5. 死亡：线程完成了它全部的工作或线程被提前强制性中止或出现异常导致结束

    在这里插入图片描述

四、线程的同步

1. 线程安全问题

  1. 多个线程执行的不确定性引起执行结果的不稳定
  2. 多个线程对数据的共享，会造成操作的不完整性，对数据造成破坏

2.在Java中通过同步机制（synchronized）来解决线程的安全问题

  1. 方式一、同步代码块
synchronuzed(同步监视器){
	//需要被同步的代码（即操作共享数据的代码，不能包含代码多了，也不能包含代码少了）
}
在继承Thread类创建的多线程的方式下，慎用this充当同步监视器，考虑使用当前类充当同步监视器
在实现Runable接口创建的多线程的方式下，考虑使用this充当同步监视器
  • 操作共享数据的代码，不能包含代码多了，也不能包含代码少了
  • 共享数据：多个线程共同操作的变量
  • 同步监视器，俗称 锁。任何一个类的对象都能充当锁(要求：多个线程必须同用一把锁)
  1. 方式二、同步方法
权限修饰符 [static] synchronized 返回类型 方法名(形参列表){//同步监视器就是this
	方法体
}
  • 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的
  • 关于同步方法的总结：‘
    1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
    2. 非静态的同步方法，同步监视器：this
      静态的同步方法，同步监视器：当前类本身
  • 同步的方式，解决了线程的安全问题 —— 好处
  • 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程。效率低 —— 局限性

3. 线程的死锁问题

  1. 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  2. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  3. 解决的方法：
    ①专门的算法、原则
    ②尽量减少同步资源的定义
    ③尽量避免同步嵌套

4. Lock（锁）

  1. 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
  2. java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  3. ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。
  4. 步骤：
    ①实例化ReentrantLock类
    private ReentrantLock lock = new ReentrantLock();
    ②调用锁定方法lock()
    lock.lock();
    ③调用解锁方法unlock()
    lock.unlock();
package com.zc.test.thread;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ZC
 * @Description 解决线程安全问题的方式三：Lock锁 ———— JDK5.0新增
 * @date 2020-06-29 23:05
 */
public class LockTest {
    public static void main(String[] args) {
        Runnable w = new Window_s4();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}


class Window_s4 implements Runnable{

    private int ticket = 100;

    // 1. 实例化ReentrantLock类
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try{
                //2. 调用锁定方法lock()
                lock.lock();
                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName()+"卖票咯，票号："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法unlock()
                lock.unlock();
            }
        }
    }
}

5. synchronzied和Lock的异同

Java学习之路（三）：不同结构的区别(更新中) ——第11点

6.优先使用顺序

Lock —> 同步代码块（已经进入了方法体，分配了相应资源） —> 同步方法（在方法体之外）

五、线程的通信

  • 涉及到的三个方法
    1. wait()：一旦执行此方法，线程会进入阻塞状态，并释放同步监视器
    2. notify()：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就会唤醒优先级高的线程
    3. notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程
  • 说明
    1. wait()、notify()、notifyAll()这三个方法必须使用在同步代码块或同步方法中
    2. wait()、notify()、notifyAll()这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现java.lang.IllegalMonitorStateException异常
    3. wait()、notify()、notifyAll()这三个方法是定义在java.lang.Object类中（因为任何一个类的对象都可以充当同步监视器）
  • 例子：
package com.zc.test.thread;

/**
 * @author ZC
 * @Description  线程通信的例子：使用两个线程打印1-100，线程1和线程2交替打印
 * @date 2020-06-30 9:40
 */
public class CommunitcationTest {

    public static void main(String[] args) {
        Number_ number_ = new Number_();
        Thread t1 = new Thread(number_);
        Thread t2 = new Thread(number_);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }


}

class Number_ implements Runnable {

    private int number = 1;

    @Override
    public void run() {

        while(true){

            synchronized (this) {
                notify();//唤醒执行wait方法的线程
                if (number <= 100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态，执行wait会释放锁
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }
        }
    }
}

六、JDK5.0新增线程创建方式

1. 创建多线程之方式三：实现Callable接口

  • 与Runnable相比，Callble功能更强大写
    1. 相比run()方法，可以有返回值
    2. 方法可以抛异常,被外面的操作捕获，获取异常信息
    3. 支持泛型的返回值
    4. 需要借助FutureTask类，比如获取返回结果
  • Future接口
    1. 可以对具体Runable、Callable任务的执行接口进行取消、查询是否完成、获取结果等。
    2. FutureTask是Future接口的唯一实现类
    3. FutureTask同时实现了Runable和Future接口。它既可以作为Runable被线程执行，又可以作为Future得到Callable的返回值

步骤：

  1. 创建Callable接口的实现类
  2. 实现Callable接口中的call()方法，将此线程需要执行的操作声明在call()中
  3. 创建Callable实现类的对象
  4. 将Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
  5. 将FutureTask的对象作为参数传递到Thread的构造器中，创建Thread的对象，并调用start()
  6. 可通过FutureTask对象的get()方法获取Callable中call()的返回值
package com.zc.test.thread;

/**
 * @Description 创建线程的方式三：实现Callable接口   JDK5.0新增
 * @author ZC
 * @date 2020-06-30 11:17
 */

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadNew {
    public static void main(String[] args) {
        // 3.创建Callable实现类的对象
        NumThread numThread = new NumThread();
        // 4.将Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask task = new FutureTask(numThread);
        // 5.将FutureTask的对象作为参数传递到Thread的构造器中，创建Thread的对象，并调用start()
        new Thread(task).start();

        try {
            //6.可通过FutureTask对象的get()方法获取Callable中call()的返回值
            //get()返回值即为FutureTask构造器参数Callable对象的call()方法的返回值
            Object o = task.get();
            System.out.println("总和为："+o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1. 创建Callable接口的实现类
class NumThread implements Callable{
    //2.实现Callable接口中的call()方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
            sum += i;
        }
        return sum;
    }
}

2.创建多线程之方式四：使用线程池

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能的影响很大。
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完返回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
  • 好处
    1. 提高响应速度（减少了创建新线程的时间）
    2. 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
    3. 便于线程管理
      ① corePoolSize：核心池的大小
      ② maximumPoolSize：最大线程数
      ③ keepAliveTime：线程没有任务时最多保持多长时间后会终止
      。。。。

  • JDK5.0起提供了线程池相关API：ExecutorService 和 Executors

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

    1. void execute(Runable command)：执行任务/命令，没有返回值，一般用来执行Runable
    2. Future submit(Callable task): 执行任务/命令，有返回值，一般用来执行Callable
    3. void shutdown()：关闭连接池

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

    1. Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
    2. Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
    3. Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
    4. Executors.newScheduledThreadPool(n)：创建一个线程池，他可安排在给定延迟后运行命令或者定期的执行

  • 步骤

    1. 创建指定数量的线程池
    2. 执行指定线程的操作,需要提供Runnable接口或Callable接口的对象作为参数
package com.zc.test.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Description 创建线程的方式四：使用线程池
 * @author ZC
 * @date 2020-06-30 12:04
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1.创建指定数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //设置线程池的属性
        /*ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
        service1.setCorePoolSize();
        service1.setKeepAliveTime();
        service1.setMaximumPoolSize();
        service1.setRejectedExecutionHandler();
        service1.setThreadFactory();*/

        //2.执行指定线程的操作,需要提供Runnable接口或Callable接口的对象作为参数
        service.execute(new NumberThread());//适合适用于Runnable
        service.submit(new NumberThread2());//适合适用于Callable

        //关闭连接池
        service.shutdown();
    }
}

class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

class NumberThread2 implements Callable {

    @Override
    public Object call() {
        for (int i = 100; i < 200; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        return null;
    }
}
@zzy
关注
专栏目录
Java中多线程
weixin_39735358的博客
10-23 237
java多线程
Java高级编程之多线程
weixin_44508223的博客
06-16 259
Java编程之多线程 补充： Eclipse每一个workspce都有一个.metaspace，包含该工作空间的一些配置。 而IntelliJIDEA则有一个统一的config文件夹 Eclipse中的workspace相当于IDEA中的project Eclipse中的project相当于IDEA中的Module 关于idea安装： 从官网下载.exe文件，然后配置 ...
Java面试知识点（二）——Java基础之多线程
AKATian的博客
06-11 181
1.程序 完成特定任务，使用某种语言编写的一组指令的集合（一段静态的代码） 2.进程（Process） 一次程序的执行过程，正在运行的一个程序（有它自身产生存在消亡的过程） 进程作为资源的分配单位，系统在运行时会分配不同的内存区域 3.线程（Thread） 进程可以进一步细化成为线程（一个程序内部的一条执行路径） 若一个进程在同一时间并行多个线程，那么就是支持多线程的 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC） 一个进程中的多个线程共享一个方法区和堆，使得线程间的通信更加简便、
Java 线程的使用
weixin_53472653的博客
06-02 3424
尚硅谷学习笔记
Java多线程详解
a549654065的博客
07-28 202
一、基本概念 程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process) 进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java并发学习 7: 线程之间的通信
过道
04-10 2870
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
java7源码-thread:多线程相关的学习
06-04
Java多线程 [TOC] 线程状态 1.New：尚未启动的线程的线程状态 2.Runnable：可运行线程的线程状态，等待CPU调度 3.Blocked：线程阻塞等待监视器锁定的线程状态 4.Waiting：等待线程的线程状态(wait、join、park) 5....
Java多线程编程详解：核心概念与高级技术应用
最新发布
10-16
使用场景及目标：① 学习 Java中线程的基础知识和技术细节；② 掌握线程的创建、控制、同步与通信；③ 使用高级并发工具类和框架优化程序性能；④ 避免常见的多线程编程错误和陷阱。 其他说明：本文不仅提供了理论...
Concurrent_Java8:多线程和Java8学习
04-27
"Concurrent_Java8:多线程和Java8学习"是一个专注于研究如何在Java 8环境中有效地利用并发特性的资源。这个压缩包可能包含了一系列的源代码示例，帮助开发者深入理解并发编程的关键概念。 首先，我们来讨论多线程。...
java单线程和多线程的区别_Java多线程详解之一：线程创建
weixin_29499957的博客
02-13 1595
一、线程、进程、多线程1、线程与进程定义进程：进程是系统进行资源分配和调度的基本单位，是操作系统中一个运行的程序，是线程的容器；线程：线程是处理机调度的最小单位，包含在进程中，是进程中实际运作单位；一个例子：比如说我们的华为手机，操作系统是安卓，手机里的应用是进程，比如微信，而微信里的发语音、发文字、拍一拍等功能就是一个个线程。2、线程与进程的区别调度：线程是处理机调度的基本单位，进程是资源分配的...
JDK+Android studio安装（超详细，手把手教，各种坑的解决问题）
qq_42826747的博客
11-12 1万+
第一步：下载安装JDK 链接如下： 64位：https://pan.baidu.com/s/1fx6Hf1wIpzspE2_kdJZkPQ 提取码：todn 32位：https://pan.baidu.com/s/13rycuew1-HVFNPyS96yG0w 提取码：qoyl 下载完成后，将压缩包，解压自己想要放的文件夹里 找到自己解压出来的文件，双击安装，我这个是64位 点击后下面的场景，按...
mybatis 注解的方式查询数据，查询参数中有List，返回结果也为list
qq_42826747的博客
05-04 2745
一、po层的代码 package com.zc.entities.po; import lombok.Data; import org.springframework.format.annotation.DateTimeFormat; import java.util.Date; /** * Created by ZC */ @Data public class Blog { ...
在云服务器如何上部署springboot项目
qq_42826747的博客
05-13 2478
开发环境 本地系统: window10 云服务器 :CentOS 7.4 64位(使用的是阿里云的服务器) 云服务器面板管理工具：宝塔 开发工具：IntelliJ IDEA 项目管理：Maven 第一步：部署服务器环境 如果是第一次使用服务器建议先到下面这个网址的教程学习一下如何使用服务器（阿里云的教程） 阿里云推荐的云服务器教程（点击即可跳转） 网址：https://developer.aliyun.com/course/71?spm=a2c6h.13788107.J_7606789820.4.
SpringBoot打包后添加外部配置文件
qq_42826747的博客
03-22 716
如果是比较高版本的springboot(如2.0以上的) ①要覆盖内部配置的 在命令行运行对应的jar包 并在后面添加–spring.config.location=配置文件路径 ②要和内部文件形成互补的，则在后面添加–spring.config.additional-location=配置文件路径 如果实较低版本的 则可以使用–spring.config.location=配置文件路径 与内...
springboot配置servlet容器的两种方法
qq_42826747的博客
04-05 559
学习springboot整合篇-_雷丰阳_尚硅谷篇中的对配置嵌入式Servlet容器的两种方法 一、直接在配置文件中配置，如web项目中的配置文件是application.yml，则这样配置 server: servlet: context-path: /crud tomcat: uri-encoding: UTF-8 即通过 server: XXX: XX...
Java学习之路（十七）：NIO
qq_42826747的博客
11-06 439
一 Java NIO 简介 二 Java NIO 与 IO的主要区别 三 缓冲区（Buffer）和通道（Channel） 1. 缓冲区（Buffer） 缓冲区：在Java NIO 中负责数据的存取。缓冲区就是数组，用于存储不同数据类型数据 根据数据类型不同（boolean除外），提供了相应类型的缓冲区 ① ByteBuffer ② CharBuffer ③ ShortBuffer ④ IntBuffer ⑤ LongBuffer ⑥ FloatBuffer ⑦ DoubleBuffer 获取缓冲区
Java多线程学习笔记：线程状态与同步机制
"这篇学习笔记主要探讨了多线程的概念、创建与启动方式、线程方法、线程的生命周期及状态、系统锁synchronized的使用和特性，包括可重入锁和锁升级机制。" 在Java编程中，多线程是一项重要的并发处理技术，它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值