java多线程的学习笔记

最新推荐文章于 2024-06-29 11:59:11 发布
最新推荐文章于 2024-06-29 11:59:11 发布
阅读量145 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43213562/article/details/118765000
版权

Java---多线程

一、多线程

1.线程与进程

  • 进程
    是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
    线程
  • 线程
    是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少
    有一个线程
    线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分
    成若干个线程

2.线程调度

  • 分时调度

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

  • 抢占式调度

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

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

3.并发与并行

  • 并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。

  • 并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。

4.线程中断

//添加中断标记
thread.interrupt();

代码如下：

    public static void main(String[] args) {
        Runnable myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        //添加中断标记
        thread.interrupt();
    }
    static class  MyThread implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //发现中断标记会进入catch方法，直接return，会终止线程
                    return;
                }
            }

        }
    }
}

5.守护线程

当最后一个用户线程死亡时，所有守护线程自动死亡
设置守护线程需在线程启动之前设置。
Runnable myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.setDaemon(true);
thread.start();

二、创建线程的三种方式

1、继承Thread类

编写一个类myThread 继承Thread类；
在main方法中创建这个类的对象，调用start()方法，启动线程；

public class Demo5 {
    public static void main(String[] args) {
        Thread myThread = new myThread();
          myThread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("我是main线程"+i);
        }

    }
   static  class myThread extends Thread {
         @Override
         public void run() {
             //这里表示一条新的执行路径
             //这个执行方式发触发方式，不是调用run方法，而是通过这个继承了Thread类的对象调用start方法启动任务
             for (int i = 0; i < 10; i++) {
                 System.out.println("我是myThread线程"+i);
             }
         }
     }
}

运行main方法，可以看到Java线程的抢占式运行;在这里插入图片描述

2、实现Runnable接口

1、编写一个类myThread 实现Runable接口；
在main方法中创建这个类的对象，即一个线程任务，创建Thread对象调用start()方法执行该任务，启动线程；

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

        Runnable myThread = new myThread();
        Thread thread = new Thread(myThread);
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是main线程"+i);
        }

    }
   static  class myThread implements Runnable {
         @Override
         public void run() {
             //这里表示一条新的执行路径
             //这个执行方式发触发方式，不是调用run方法，而是通过这个继承了Thread类的对象调用start方法启动任务
             for (int i = 0; i < 10; i++) {
                 System.out.println("我是实现Runable的线程"+i);
             }
         }
     }
}

运行main方法，可以看到Java线程的抢占式运行;
在这里插入图片描述2、该步骤可以使用匿名类的方式实现，代码如下：

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

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("我是实现Runable的线程"+i);
                }
            }
        });
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是main线程"+i);
        }

    }
}

3、实现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();

使用实例：

public class Demo6 {
    public static void main(String[] args) {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);     //创建FutureTask对象 , 并传入第一步编写的Callable类对象
        new Thread(task).start();       //通过Thread,启动线程
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "  " + i);
        }
    }


    static class MyCallable implements Callable<Integer> {      //编写类实现Callable接口 , 实现call方法

        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  " + i);
            }
            return 100;
        }
    }

}

4、Runnable和Callable的区别

 1）接口定义：

     //Callable接口
public interface Callable {
V call() throws Exception;
}

//Runnable接口
public interface Runnable {
public abstract void run();
}

2)  不同点
  • 两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
  • Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；
3)注意点

Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

三、线程安全问题

先看一段线程不安全代码实例：

public class Demo5 {
    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 = 10;

        @Override
        public void run() {
            while (count > 0) {
                //买票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功,余票" + count);
            }
        }
    }
}

执行结果：
在这里插入图片描述

上段代码意义为对同一个卖票任务同时启动了三个线程窗口进行卖票。可以看到出现余票负数的情况，按照代码逻辑，不可能出现负数，但是由于线程的抢占机制，三个线程是并发执行的，就会产生这种线程不安全的现象。

1、同步代码块-线程安全

对需要执行的任务使用synchronized 关键字进行上锁，上述问题可以通过同步代码块的方式实现线程安全：

public class Demo5 {
    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 = 10;
        //创建一个锁对象
        private Object lock = new Object();

        @Override
        public void run() {
            //使用synchronized关键字对任务进行上锁
            synchronized (lock) {
                while (true) {
                    if (count == 0) {
                        break;
                    }
                    //买票
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println("出票成功,余票" + count);
                }
            }
        }
    }
}

在这里插入图片描述
可以看到控制台打印正常了，没有出现负数的情况。

2、同步方法-线程安全

将需要执行的任务放在一个单独的方法中，使用synchronized 关键字修饰该方法，实现与同步代码快一样的效果，代码如下：

public class Demo5 {
    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 = 10;
        //创建一个锁对象
        private Object lock = new Object();

        @Override
        public void run() {
            show();
        }
        
        private synchronized void show() {

            while (true) {
                if (count == 0) {
                    break;
                }
                //买票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功,余票" + count);
            }
        }
    }
}

3、 显式锁–线程安全

同步代码块和同步方法都属于隐式锁，创建显示锁的方式：
//创建显示锁对象
Lock l = new ReentrantLock();
（当传入参数为true时，为公平锁，默认false)

//当有线程进来时，对任务上锁
l.lock();
//当该线程结束时，释放锁
l.unlock();
代码示例：

public class Demo5 {
    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 = 10;
        //创建显示锁对象
        Lock l = new ReentrantLock();
        @Override
        public void run() {
            //使用显式锁对任务进行上锁
            while (true) {
                //当有线程进来时，对任务上锁
                l.lock();
                if (count == 0) {
                    break;
                }
                //买票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功,余票" + count);
                //当该线程结束时，释放锁
                l.unlock();
            }
        }
    }
}

4、线程死锁

  • 死锁定义

    所谓死锁是指多个线程因竞争资源而造成的一种僵局(互相等待)，若无外力作用，这些进程都将无法向前推进。

  • 产生死锁的必要条件

互斥条件：线程要求对所分配的资源(如打印机)进行排他性控制，即在一段时间内某资源仅为一个线程所占有。此时若有线程请求该资源，则请求线程只能等待。

不剥夺条件：线程所获得的资源在未使用完毕之前，不能被其他线程倾向夺走，即只能由获得该资源的线程自己来释放(只能是主动释放)。

请求和保持条件：线程已经保持了至少一个资源，但又提出了新的资源请求，而该线程已被其他线程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

循环等待条件：存在一种线程资源的循环等待链，链中每一个线程已获得的资源同时被链中下一个线程所请求。即存在一个处于等待状态的线程集合{P1,P2,…,Pn}，其中Pi等待的资源被P(i+1)占有(i=0,1,…,n-1)，Pn等待的资源被P0占有

死锁示例：

/**
 * 一个简单的死锁类
 * 当DeadLock类的对象flag==1时(td1)，先锁定o1，睡眠500ms
 * 而td1在睡眠的时候另一个flag==0的对象(td2)线程启动，先锁定o2，睡眠500ms
 * td1 睡眠结束后需要锁定 o2 才能继续执行，而此时 o2 已被 td2 锁定；
 * td2 睡眠结束后需要锁定 o1 才能继续执行，而此时 o1 已被 td1 锁定；
 * td1、td2 相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。
 */
public class DeadLock implements Runnable {
    public int flag = 1;
    //静态对象是类的所有对象共享的
    private static Object o1 = new Object(), o2 = new Object();

    @Override
    public void run() {
        System.out.println("flag="+flag);
        if(flag==1){
            synchronized (o1){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2){
                    System.out.println("1");
                }
            }
        }
        if(flag==0){
            synchronized (o2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1){
                    System.out.println("0");
                }
            }
        }
    }
    public static void main(String[] args) {
        DeadLock td1 = new DeadLock();
        DeadLock td2 = new DeadLock();
        td1.flag=1;
        td2.flag=0;
        //td1，td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的。
        //td2的run()可能在td1的run()之前运行
        new Thread(td1).start();
        new Thread(td2).start();
    }
}

四、线程池

线程池的好处

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。
    Java中的四种线程池 概述

1. 缓存线程池

/**
 * 缓存线程池
 * (长度无限制)
执行流程:
判断线程池是否存在空闲线程
存在则使用
不存在,则创建线程 并放入线程池, 然后使用
 */
public class Demo {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        executorService.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                                    }
                                }
        );
        executorService.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                                    }
                                }
        );
        executorService.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                                    }
                                }
        );
        //休眠后线程进入空闲状态
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.execute(new Runnable() {
                                    @Override
                                    public void run() {
                                        System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                                    }
                                }
        );
    }

2、定长线程池

public class Demo2 {
    /**
     * 定长线程池
     * (长度是指定的数值)
	 *执行流程:
	 *判断线程池是否存在空闲线程
	 *存在则使用
	 *不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
	 *不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

3、单线程线程池

效果与定长线程池 创建时传入数值1 效果一致.
单线程线程池.
执行流程:

  • 判断线程池 的那个线程 是否空闲
  • 空闲则使用
  • 不空闲，会等待池中的单个线程空闲后使用
///新建一个单线线程池对象  newSingleThreadExecutor();
ExecutorService service = Executors.newSingleThreadExecutor();

4、周期性线程池

周期任务 定长线程池.

执行流程:

  • 判断线程池是否存在空闲线程
  • 存在则使用
  • 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  • 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
public class Demo4 {
    /**
     * 周期定长线程池
     */
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1.定时执行一次
         * arg1  定时执行的任务
         * arg2 时长数字
         * arg3 时长数字的时间单位
         */
          service.schedule(new Runnable() {
              @Override
              public void run() {
                  System.out.println("锄禾日当午");
              }
          },5, TimeUnit.SECONDS);

        /**
         * 周期性执行任务
         * arg1 任务
         * arg2 延迟时长数字
         *arg3 周期时长数字（每隔多久执行一次）
         * arg4 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("汗滴禾下土");
            }
        },5,1,TimeUnit.SECONDS);
    }

}
qun_groot
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java多线程学习笔记
03-01
这篇文档和对应的源代码 博文链接：https://interper56-sohu-com.iteye.com/blog/172303
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 290
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 526
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
微服务和kafka
m0_51586984的博客
06-26 1201
ZooKeeper 是一个开源的分布式协调服务，ZooKeeper框架最初是在“Yahoo!"上构建的，用于以简单而稳健的方式访问他们的应用程序。后来，Apache ZooKeeper成为Hadoop，HBase和其他分布式框架使用的有组织服务的标准。例如，Apache HBase使用ZooKeeper跟踪分布式数据的状态。ZooKeeper 的设计目标是将那些复杂且容易出错的分布式一致性服务封装起来，构成一个高效可靠的原语集，并以一系列简单易用的接口提供给用户使用。
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 263
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
解决Java中的数组越界异常的技术
weixin_44627014的博客
06-26 369
通过本文的讨论，我们了解了如何有效地处理Java中的数组越界异常。预防异常的发生，合理使用异常处理机制以及考虑使用集合类来替代数组，是确保Java应用程序稳定性和可靠性的关键步骤。
编译正则表达式模式re.compile
liujingwei8610的专栏
06-27 156
print("【执行】pattern.findall('这里有123个苹果和45个橘子')")result = pattern.findall('这里有123个苹果和45个橘子')print(f"【显示】pattern={pattern}")print(f"【显示】result={result}")根据给定的Python代码，哪个选项是正确的？A选项：返回值可以进行search操作。B选项：返回值可以进行match操作。D选项：参数为要编译的正则表达式模式。C选项：参数为要搜索的字符串。
Java 中的访问修饰符及其适用范围
liangzai215的专栏
06-25 627
public就像是开放的公园，对所有人开放。private好比你的私人日记，只有你能看。protected则是家庭相册，家人和继承者可以看到。而默认访问级别，则像是一扇未上锁的后门，只对同在一个包的“家人”开放。合理使用这些访问修饰符，可以帮助你构建更加安全、模块化和易于维护的代码。就像管理家中的物品一样，通过设置合适的访问权限，让每个部分各司其职，既保护了隐私，又促进了内部的合作与协调。
深入理解装饰者模式（Decorator Pattern）及其实际应用
qq_40254606的博客
06-25 1140
装饰者模式是一种结构型设计模式，它允许你通过将对象放入包含行为的特殊封装对象中来为原对象添加新的行为。装饰者模式提供了比继承更灵活的扩展功能的方法，因为它可以在运行时动态地添加功能。装饰者模式通过在运行时动态地为对象添加功能，提供了一种比继承更灵活的扩展方式。在Java I/O库中的应用展示了装饰者模式的实际效果，提高了代码的灵活性和可扩展性。希望这篇文章对你理解装饰者模式有所帮助。
Android10 SystemUI系列 需求定制（二）隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等
fighting_2017的博客
06-25 230
SystemUI 所包含的界面和模块比较多，这一节主要分享一下状态栏通知图标和通知栏的定制需求：隐藏状态栏通知图标，锁屏通知，可定制包名，渠道等来熟悉一下Systemui。
JavaScript的学习之图片的切换
人生苦短
06-27 670
这节的JS图片切换的学习就告一段落！添加JS代码，让它实现图片切换的功能。点击按钮可以切换上一张和下一张。随便去网上找几张图片素材。
multiprocessing.Queue 多个进程生产和多个进程消费怎么处理
qh0526wy的博客
06-24 389
在主进程中，我们创建了多个消费者和生产者进程，并将它们启动。生产者进程将数据放入队列，消费者进程从队列中取出数据并处理。生产者进程完成后，我们向队列发送。进行多个生产者和多个消费者的场景时，队列可以很好地协调这些进程。这个模式允许多个生产者并发地向队列中放入数据，同时多个消费者并发地从队列中取出并处理数据，直到所有生产者完成生产，消费者接收到结束信号。函数，分别用于从队列中获取数据和向队列中放入数据。来确保队列可以在多个进程之间共享。方法等待队列中的所有任务完成时很有用。在这个示例中，我们创建了一个队列。
计算机等级考试-Java考试大纲
weixin_54454406的博客
06-27 152
二级Java语言程序设计考试大纲。
RocketMQ快速入门：事务消息原理及实现（十）
55555的博客
06-28 772
最后一句话总结一下，rocketmq的事务消息，是通过half消息（即二阶段提交）+回查机制来实现的。
mapstruct实现各个实体间的类型转换（DTO转BO、BO转Entity）的实践
m0_73376570的博客
06-26 1057
***/@Data@Data@Mapper//将DTO转换为BO//将List<BO>转换为List<DTO>//将BO转换为DTO。
Mybatis
qq_62366797的博客
06-24 443
开启二级缓存之后，每个SQLSession进行查询动作时会先去二级缓存中看是否有，如果有就直接命中，如果没有则去看一级缓存中有没有，如果还没有就只能去数据库中查。首先Mybatis是提供了两级缓存的机制去提高数据的检索效率，避免每一次都去数据库中查数据。默认情况下是开启一级缓存(SqlSession级别的缓存，也称为本地缓存)，在一级缓存下，每个SQLSession都会把从数据库查询到的数据保存在自己的一级缓存中，当该SQLSession下次进行相同的查询时就可以直接走缓存而不用去数据库中查。
根据类上的注解信息生成创建表的SQL语句
沐雨橙风ιε的博客
06-28 253
定义一个实体类，在字段上使用knife4j的接口文档注解@ApiModelProperty注解指定字段名。
学习多线程使用这个笔记就够了
02-02
"这篇资料是关于Java多线程学习的笔记，涵盖了从基础到高级的知识，适合初学者和进阶者。" 在计算机科学中，多线程是提高程序执行效率的重要技术。Java语言提供了丰富的支持来实现多线程编程。这篇笔记首先介绍了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值