2021-07-16

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量82 收藏 1
点赞数
分类专栏： Java SE Thread 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46907295/article/details/118789414
版权

多线程

process(进程)与Thread(线程)

  • 说起进程，就不得不说程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
  • 进程是执行程序的过程，是一个动态的概念。是系统资源分配单位
  • 通常一个进程中可以有多个线程，当然一个进程至少一个线程，不然没有存在的意义。线程是CPU调度和执行的单位

注意：

​ 很多多线程是模拟出来的，真正的多线程是指cpu即多核，如服务器。如果模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉；

线程

  • 线程分用户线程和守护线程；虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕

  • 线程就是独立的执行路径;

  • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程, gc(垃圾回收)线程;

  • main()称之为主线程，为系统的入口，用于执行整个程序;

  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器(CPU)安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。

  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;

  • 线程会带来额外的开销，如cpu调度时间，并发控制开销。

  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

  • 死亡后的线程不可以再次被启用

线程的创建

三种方式

继承Thread类

  1. 自定义线程类继承Thread类；

  2. 重写run方法，编写程序执行体；

  3. 创建线程对象，调用**start()**方法启动线程；

  4. 线程开启不一定立即执行，有CPU调度安排；

    不建议使用：避免OOP单继承局限性！

package com.zhou.thread;

public class runThreadDome01 extends Thread{
    @Override//重写 run方法
    public void run() {
//       run方法体
        for (int i = 0; i < 20; i++) {
            System.out.println("我想你了：");
        }
    }

    public static void main(String[] args) {
//        创建线程类对象
        runThreadDome01 run01 = new runThreadDome01();
//        调用start方法开启线程
        run01.start();
        for (int i = 0; i < 20; i++) {
            System.out.print("你想我没！");
        }
    }
}

案例

package com.zhou.thread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习Thread，实现多线程同步下载图片
public class runThreadDome02 extends Thread{
//成员属性，downloader所需参数
    private String url;
    private String name;
//构造方法，创建对象时初始化成员变量
    public runThreadDome02(String url,String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为" + name);
    }

    public static void main(String[] args) {
        runThreadDome02 run01 = new runThreadDome02("https://pineapple.edgeless.top/picbed/home/f1.jpg","Thread1.jpg");
        runThreadDome02 run02 = new runThreadDome02("https://pineapple.edgeless.top/picbed/home/f2.jpg","Thread2.jpg");
        runThreadDome02 run03 = new runThreadDome02("https://pineapple.edgeless.top/picbed/home/f3.jpg","Thread3.jpg");
        run01.start();
        run02.start();
        run03.start();
    }
}
//下载器
class WebDownloader{
//    下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            System.out.println("IO异常，dounloader方法出现问题");
        }

    }
}

实现Runnable接口

  1. 定义一个类实现Runnable接口；

  2. 实现run()方法，编写线程执行体；

  3. 创建线程对象，调用**start()**方法启动线程；

    建议使用：避免了单继承的局限性，灵活方便，方便同一个对象被多个线程的使用！

package com.zhou.thread;
//创建线程二，实现Runnable接口
public class ThreadRunnableDome02 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("明慧是傻子！");
        }
    }

    public static void main(String[] args) {

        ThreadRunnableDome02 Runnable01 = new ThreadRunnableDome02();
//        创建线程对象，通过线程对象来开启我们的线程，代理
//        通过Thread构造方法传一个Runnable实现类对象
//        创建一个关于Runnable实现类有关的线程，
//        通过start开启线程；
        Thread thread = new Thread(Runnable01);
        thread.start();
//        代码简化使用匿名对象:
//        new Thread(Runnable01).start();
        for (int i = 0; i < 20; i++) {
            System.out.print("明慧不是傻子！");
        }
    }
}

实现Callable接口

  1. 实现Callable接口，有返回值；
  2. 重写**call()**方法，需要抛出异常；
  3. 创建目标线程；
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1)；
  5. 提交执行服务：Future result1 = ser.submit(t1);
  6. 获取结果：boolean r1 result1.get()
  7. 关闭服务：ser.shutdownNow()
多个线程操做一个对象
package com.zhou.thread;
//多个线程同时操作一个对象
//买火车票案例
public class ThreadDome01 implements Runnable{

//    票数
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true){
//            ticket：票的意思；
            if (ticketNums<=0){
                break;
            }
//            sleep()线程休眠参数是毫秒；
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//            currentThread()(获取当前线程).getName()（获取线程名）
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "票");
        }
    }

    public static void main(String[] args) {
        ThreadDome01 threadDome01 = new ThreadDome01();

        new Thread(threadDome01,"黄牛1").start();
        new Thread(threadDome01,"黄牛2").start();
        new Thread(threadDome01,"黄牛3").start();
    }
}
//运行结果
//    黄牛3拿到了第10票
//    黄牛2拿到了第10票
//    黄牛1拿到了第10票
//    黄牛2拿到了第9票
//    黄牛3拿到了第8票
//    黄牛1拿到了第7票
//    黄牛2拿到了第6票
//    黄牛3拿到了第5票
//    黄牛1拿到了第4票
//    黄牛3拿到了第3票
//    黄牛2拿到了第3票
//    黄牛1拿到了第2票
//    黄牛2拿到了第1票
//    黄牛3拿到了第1票
//    黄牛1拿到了第0票

发现：有多个线程操作一个数据：出现线程安全问题
解决办法：

静态代理:

​ 实现接口

Lambda表达式

  • 希腊字母表中排序第十一位的字母，英文名为Lambda
  • 避免匿名内部类定义过多；
  • 让代码看起来简洁；
  • 属于函数式编程；
  • 去掉一堆没有意义的代码，只留下了核心逻辑；
Lambda表达式重要特征:
  • **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。
  • **使用Lambda表达式前提：**是一个函数式接口；
  • **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。
  • **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。
  • **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
函数式接口

Functional Interface（函数式接口）

定义：只包含唯一一个抽象方法的接口

对于函数式接口我们可以通过lambda表达式来创建该接口的对象；

Lambda案例

package com.zhou.thread;

public class LambdaDome01 {

//（第一次简化）外部的类拿过来改成静态内部类
/*
    static class Love implements zhou{
        @Override
        public void love(String a, String b) {
            System.out.println(a+ "Love"+ b);
        }
    }
*/



    public static void main(String[] args) {
//      （第二次简化）  把静态内部类改成局部内部类
/*
        class Love implements zhou{
            @Override
            public void love(String a, String b) {
                System.out.println(a+ "Love"+ b);
            }
        }
*/
//              第三次把原来代码注释掉
/*        zhou love = new Love();
        love.love("周林","孙明慧");
    }*/

//    第三次简化，把原来代码注释掉改成匿名内部类
/*
        zhou love = new zhou()*/
/* new Love(); 把原来的 new 类名 改为new 接口实现类*//*
 {
            @Override
            public void love(String a, String b) {
                System.out.println(a+ "Love"+ b);
            }
        };
        love.love("周林","孙明慧");
        */

        //        转换成Lamdba表达式
/*        zhou love = (String a,String b)->{
            System.out.println(a+ "Love"+ b);
        };*/
//        Lambda表的是简化，省去掉可参数类型，当参数为一个时可以省略参数外的外的括号
//
        zhou love = ( a, b)-> System.out.println(a+ "Love"+ b);
        love.love("周林","孙明慧");
    }
}
    interface zhou{
        void love(String a,String b);
    }
//第一次简化把外部的类放到内部
/*
     class Love implements zhou{
        @Override
        public void love(String a, String b) {
            System.out.println(a+ "Love"+ b);
        }
    }
*/

线程的五大状态：

来自狂神Java课程

​ public static enum Thread.State
​ extends Enum<Thread.State>线程状态。 线程可以处于以下状态之一：
​ NEW
​ 尚未启动的线程处于此状态。
​ RUNNABLE
​ 在Java虚拟机中执行的线程处于此状态。
​ BLOCKED//阻塞
​ 被阻塞等待监视器锁定的线程处于此状态。
​ WAITING//等待
​ 正在等待另一个线程执行特定动作的线程处于此状态。
​ TIMED_WAITING//waiting 等待
​ 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
​ TERMINATED//结束
​ 已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

状态观测

public class threadStat {

    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("周林");
        });

//        观察状态
//        调用get.state();来查看状态
        Thread.State state = thread.getState();
        System.out.println("状态是" + state);

        thread.start();//启动线程；
        state = thread.getState();//更新线程状态
        System.out.println("状态是" + state);

        while (state!= Thread.State.TERMINATED){//只要线程不终止，就一直输出状态；
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();//更新状态；
            System.out.println("状态是" + state);//输出状态
        }
    }
}
线程的方法：

setPriority(int newPriority) 更改线程权限

线程的停止：
//测试停止线程-
// 建议线程正常停止-->利用次数，不建议使用死循环。
// 建议使用标志位----->设置标志位。
// 不建议使用stop或者destroy等过时或者JDK不建议使用的方法
public class threadStop implements Runnable{
//    设置标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("线程正在运行" + i++);
        }
    }

//    设置一个公共的方法来停止线程
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        threadStop threadStop = new threadStop();
        new Thread(threadStop).start();
        
        for (int i = 0; i < 200; i++) {
            System.out.println("main"+i);
            if(i==179){
//                切换标志位让线程停止
                threadStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}
线程的休眠：
  • sleep(时间)指当前线程阻塞的毫秒数（1000毫秒等于1秒）；
  • sleep存在异常InterredException；
  • sleep时间到达后线程进入就绪状态；
  • sleep可以模拟网路延时，倒计时等；
  • 每个对象都有一个锁，sleep不会释放锁；

**模拟延时：**可以放大问题的发生性；

线程暂停（礼让yield）
  • 让当前执行的线程暂停但不阻塞；
  • 将线程从运行状态转换为就绪状态；
  • 让CPU重新调度，礼让不一定成功看CPU重新分配情况；
package com.zhou.thread;
//测试礼让，礼让不一定成功；
public class threadYield {
    public static void main(String[] args) {
        yiled yiled = new yiled();
        //Thread构造方法（线程类对象，"起的名字"）
        new Thread(yiled,"a").start();
        new Thread(yiled,"b").start();
    }
}
class yiled implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        //调用礼让方法
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束执行");
    }
}
现成的强制执行：（Join）
  • Join合并线程，待此线程执行完之后，在执行其他线程，其他线程阻塞，可以想象成插队
  • 方法：用线程对象调用**jion()**方法；
线程的优先级
  • Java提供一个线程调度器来监控程序启动后进入就绪状态的所有线程，线程的调度器按照优先级决定应该调度哪个线程来执行；
  • 线程的优先级用数字表示，范围是从1~10
  • 先设置优先级，在开启线程；默认优先级是5
  • 使用**getPriority().setPriority(int XXX)**来改变或者获取优先级；
//测试线程优先级
public class threadPriority {
    public static void main(String[] args) {
//        打印主线程优先级
        System.out.println(Thread.currentThread().getName()+"优先级是"+Thread.currentThread().getPriority());
        Priority priority = new Priority();
        Thread t1 = new Thread(priority);
        Thread t2 = new Thread(priority);
        Thread t3 = new Thread(priority);
        Thread t4 = new Thread(priority);
        Thread t5 = new Thread(priority);
        Thread t6 = new Thread(priority);
//        先设置优先级
        t1.start();//默认

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(5);
        t4.start();

        t5.setPriority(7);
        t5.start();

        t6.setPriority(9);
        t6.start();
    }
}
class Priority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"优先级是"+Thread.currentThread().getPriority());
    }
}
保护线程
  • 线程分用户线程和守护线程；
  • 虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕
  • 通过**对象名.setDaemon(true)**将一个对象设置成保护线程；
  • 一般线程setDaemon(x)里的参数X都是false代表用户线程的意思
  • 保护线程并不一定执行完毕
public class threadDaemon {
    public static void main(String[] args) {

        God god = new God();
        you you = new you();
        Thread g1 = new Thread(god);
//        设置保护线程
        g1.setDaemon(true);//默认是false表示用户线程
        g1.start();

        new Thread(you).start();
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("你爱我！");
        }
    }
}

class you implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("我爱你第"+i+"天");
        }
        System.out.println("我爱你的下一世开始");
    }
}

线程的同步

**并发：**同一个对象被多个线程操作

多个线程访问一个对象，并且某些线程还想修改这个对象，我们就需要线程的同步；

**线程同步：**其实是一种等待机制，多个需要同时访问此对象的线程进入对象的线程池形成排队等待，等待前面的使用完毕，下一个线程在使用；

  • 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时，也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
    synchronized ,当一个线程获得对象的排它锁,独占资源,其他线程必须等待，使用后释放锁即可

    但存在以下问题:

    • 一个线程持有锁会导致其他所有需要此锁的线程挂起;
    • 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时，引起性能问题;
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置，引起性能问题.
synchronized关键字
两种用法：

  1. 加了synchronized修饰符的方法叫同步方法；

    synchronized方法控制“对象”的访问，每个对象对应一把锁每个synchronized方法都必须获得调用该方法的对象锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返还才能释放锁，后面被阻塞的线程才能获得这个锁，继续执行

    ​ 缺陷：若将一个大的方法申明为synchronized将会影响效率；

    //      Synchronized:同步的意思
public class Synchronized {

    public static void main(String[] args) {
        ticket ticket = new ticket();

        new Thread(ticket,"黄牛1").start();
        new Thread(ticket,"黄牛2").start();
        new Thread(ticket,"黄牛3").start();
    }

}

class ticket implements Runnable {

    private int ticketNums = 10;
    boolean flag = true;//设置标志位，外部停止方式；

    @Override
    public void run() {

//        买票
        while (flag) {
            mTicket();
            try {
                Thread.sleep(1000);//方大问题的发生性
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //没有加synchronizd时会出现结果-1的现象
   // private  void mTicket() {
    private synchronized void mTicket() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        System.out.println(Thread.currentThread().getName() + "票卖了一张，当前票数" + ticketNums--);
    }
}
    1. 同步块：synchronized(Obj){ }其中Obj一般是一个增删改的变量；
    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class；
    • 同步监视器的执行过程：
      1. 第一个线程访问，锁定同步监视器，执行其中代码；
      2. 第二个线程访问，发现同步监视器被锁定，无法访问；
      3. 第一个线程访问完毕，解锁同步监视器；
      4. 第二个线程访问，发现同步监视器没有锁，然后锁定访问；
死锁

多个线程互相抱着对方需要的资源，然后形成僵持；

产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用；
  2. 请求与保持条件：一个进程因请求资源而堵塞时，对以获得的资源保持不放；
  3. 不剥夺条件：进程以获得的资源，在未使用完之前，不能强行剥夺；
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系；

死锁避免方法

只要破解四个必要条件之一就可；

Lock(锁)
  • JDK5.0开始，Java提供了更大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象来充当；
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象；
  • ReentrantLock(可重入锁)类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较长用的是ReentrantLock，可以显示加锁、释放锁；
//     定义一个可重用锁
    private final ReentrantLock lock = new ReentrantLock();
    public void A(){
        lock.lock();
        try {
//            要保证安全的代码；
        }finally {
            lock.unlock();
//            如果同步代码有异常，要将unlock()写到finally语句块里；
        }
    }
synchronized与Lock对比

  • Lock是显示锁（要手动开启和关闭，）synchronized是隐式锁，除了作用域自动释放；

  • Lock只是代码块锁，synchronized有代码块锁和方法锁；

  • 使用Lock锁 JVM将花费较少的时间来调度线程，性能好。并且更具有扩展性

  • 优先顺序：

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

线程通信

Java中提供了几个方法解决线程通信问题

wait() //表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)//可以指定等待毫秒数

notify()//唤醒一个处于等待的线程
notifyAll()//唤醒同一个对象上多有调用wait()方法的线程，优先级别高的线程优先调度；

线程池

**好处：**1、提高响应速度；2、降低资源消耗；3、便于管理；

​ corePoolSize：核心池的大小；

​ maximumPoolSize：最大线程数；

​ keepAliveTime：线程没有任务时保持多长时间后终止；

使用线程池

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

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

    • void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
    • Futuresubmit(Callabletask):执行任务，有返回值，一般执行Callable
    • void shutdown():关闭连接池

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

创建固定线程池
//        创建线程池子,参数是固定池子的大小
        ExecutorService service = Executors.newFixedThreadPool(10);
开启/关闭服务
 service.execute(new MyThread());//参数是线程对象；
 service.shutdown();
啊木君
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-07-18 Debug
Choulongx的博客
07-18 478
今天发现了一个低级错误 [Error] ld returned 1 exit status 回去查发现是写错了主函数名称 我是sb
CVE-2021-22205——Gitlab 远程命令执行漏洞复现
LiBai'S BLOG
11-10 9132
CVE-2021-22205Vuln Impact影响版本环境Fofa语法漏洞利用脚本反弹ShellEXP Vuln Impact An issue has been discovered in GitLab CE/EE affecting all versions starting from 11.9. GitLab was not properly validating image files that were passed to a file parser which resulted in a .
2021-07-16 安装显卡驱动和cuda报错
Graceying的博客
07-16 5403
sudo ./NVIDIA-Linux-x86_64-418.197.02.run -no-x-check -no-nouveau-check -no-opengl-files WARNING: nvidia-installer was forced to guess the X library path '/usr/lib64' and X module path '/usr/lib64/xorg/modules'; these paths were not queryable from the s
【2021-07-16】堆糖小程序
骑毛驴的猴的博客
07-16 687
2021-03-15
weixin_44902539的博客
03-15 1255
好网站 https://blog.csdn.net/u013317445/article/details/88196373?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-6.control&dist_request_id=1328641.48931.16157665162059593&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-
2021-01-05
weixin_44822406的博客
01-05 935
第一次接触这个CSDN博客，希望大家多多关照，有什么做的不好不周到的地方希望大家谅解。从现在开始会陆续发一些大家所需要的东西。
2021-07-28
lixiaoxianer的博客
07-28 4029
kubeadmin 安装k8s1.20集群 标签（空格分隔）： kubernetes架构系列 一：k8s1.20.x 的重要更新 二：k8s1.20.x 的安装 2.1 ：高可用Kubernetes集群规划 2.2 yum 的更新配置 （所有节点全部安装） 一：k8s1.20.x 的重要更新 1、Kubectl debug 设置一个临时容器 2、Sidecar 3、Volume：更改目录权限，fsGroup 4、ConfigMap和Secret K8S官网：https://kubernetes.io/
2021-01-04
wubaoyu123的博客
01-04 2252
博客园Logo 首页 新闻 博问 专区 闪存 班级 代码改变世界 搜索 注册 登录 返回主页 知了一笑 博客园 首页 新随笔 联系 订阅 管理 数据仓库组件：Hive环境搭建和基础用法 本文源码：GitHub || GitEE 一、Hive基础简介 1、基础描述 Hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载，是一个可以对Hadoop中的大规模存储的数据进行查询和分析存储的组件，Hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成
2021-07-16：最大子列和问题（C++）.cpp
07-17
2021-07-16：最大子列和问题（C++）：https://blog.csdn.net/qq_45913057/article/details/118852988
BIM智能化系统平台-智慧园区[2021-07-16]（31页）.pdf
05-20
BIM智能化系统平台-智慧园区[2021-07-16]（31页）.pdf
spring事务详细讲解-深入浅出
小电玩
09-08 397
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1407
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1337
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合——Stack详解
最新发布
yang_brother的博客
09-10 268
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 678
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 541
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 514
MyBatis面试
参数名称：period，数据类型：字符串，当前值：2021-07-16 ~ 2021-07-23，显示格式：自动，容许值：全部。现在维度A=[PERIOD]，对A这个维度解析
06-13
根据您提供的信息，A维度的取值为[PERIOD]，即A维度的值为2021-07-16 ~ 2021-07-23。这个维度可以用于数据分析和可视化，例如，可以使用这个维度来筛选和展示在2021-07-16 ~ 2021-07-23期间发生的事件或者数据。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值