Java学习笔记5-1——多线程

已于 2022-01-29 00:40:02 修改
阅读量107 收藏
点赞数
文章标签： java 开发语言 后端
于 2022-01-26 01:35:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44238066/article/details/122694740
版权

目录

前言

Process与Thread：

  • 程序（programm）是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
  • 而进程（process）是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
  • 通常在一个进程中可以包含若干个线程（thread），当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

很多多线程是模拟出来的，真正的多线程是指有多个CPU。

核心概念

  • 线程就是独立的执行路径
  • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
  • main()称之为主线程，为系统的入口，用于执行整个程序
  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
  • 线程会带来额外的开销，如cpu调度时间，并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

三种创建线程的方式：

  1. 继承Thread类【重点】
  2. 实现Runnable接口【重点】
  3. 实现Callable接口

继承Thread类

创建线程方式1：继承Thread类，重写run()方法，调用start开启线程。

  • public class Thread extends Object implements Runnable

  • 构造方法：
    Thread(Runnable target) 分配一个新的 Thread对象。
    Thread(Runnable target, String name) 分配一个新的 Thread对象，具有指定的name作为其名称

  • 常用方法：
    void start() 使此线程开始执行; JVM调用此线程的run方法。

简单例子：

//创建线程方式1：继承Thread类，重写run()方法，调用start开启线程
//总结：注意线程开启不一定立即执行，由CPU调度执行
public class ThreadTest1 extends Thread{
    @Override
    public void run() {
        //run方法线程的执行体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学线程---"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        ThreadTest1 tt = new ThreadTest1();

        //调用start()
        tt.start();
        
        for (int i = 0; i < 1000; i++) {
            System.out.println("（主）我在看代码---"+i);
        }

    }
}

网图下载例子：

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{

    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestThread2(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) {
        TestThread2 t1 = new TestThread2("https://www.kuangstudy.com/assert/course/c1/01.jpg","图片1.jpg");
        TestThread2 t2 = new TestThread2("https://www.kuangstudy.com/assert/course/c1/02.jpg","图片2.jpg");
        TestThread2 t3 = new TestThread2("https://www.kuangstudy.com/assert/course/c1/03.jpg","图片3.jpg");

        t1.start();
        t2.start();
        t3.start();

    }
}
//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，Downloader出现问题");
        }
    }
}

实现Runnable接口

创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法。

  • public interface Runnable：
    Runnable接口应由任何类实现，其实例将由线程执行。 该类必须定义一个无参数的方法，称为run 。

简单例子：

//创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class ThreadTest3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学线程---"+i);
        }
    }

    public static void main(String[] args) {

        //创建Runnable接口的实现类对象
        ThreadTest3 tt = new ThreadTest3();

        //创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(tt).start();
        

        for (int i = 0; i < 1000; i++) {
            System.out.println("（主）我在看代码---"+i);
        }
    }
}

上述两个方法小结

继承Thread类：

  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用。为了避免面向对象单继承局限性

实现Runnable接口：

  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用。能避免单继承局限性，灵活方便，方便同一对象被多个线程使用。 例如：
//一份资源
ThreadTest tt = new ThreadTest();

//多个代理
new Thread(tt,"张三").start();
new Thread(tt,"李四").start();
new Thread(tt,"你好").start();

代码例子（龟兔赛跑）作为总结：

//模拟龟兔赛跑
public class Race implements Runnable{
    //胜利者
    private static String  winner;
    
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }


            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){
            //已经存在胜利者
            return true;
        }
        {
            if (steps>=100){
                winner=Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }

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

        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();
    }
}

实现Callable接口

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
  5. 提交执行：Future\<Boolean\> result1 = ser.submit(t1);
  6. 获取结果：boolean r1 = result1.get();
  7. 关闭服务：ser.shutdownNow();

网图下载例子：

//线程创建方式3：实现Callable接口
//Callable的好处：1.可以定义返回值；2.可以抛出异常

public class CallableTest implements Callable<Boolean> {
    private String url;//网络图片地址
    private String name;//保存的文件名

    public CallableTest(String url,String name){
        this.url = url;
        this.name = name;
    }
    //  下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader1 webDownloader = new WebDownloader1();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name+"的文件");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTest ct1 = new CallableTest("https://www.kuangstudy.com/assert/course/c1/01.jpg","c图片1.jpg");
        CallableTest ct2 = new CallableTest("https://www.kuangstudy.com/assert/course/c1/02.jpg","c图片2.jpg");
        CallableTest ct3 = new CallableTest("https://www.kuangstudy.com/assert/course/c1/03.jpg","c图片3.jpg");
        // 创建执行对象
        ExecutorService ser = Executors.newFixedThreadPool(3);

        // 提交执行：
        Future<Boolean> r1 = ser.submit(ct1);
        Future<Boolean> r2 = ser.submit(ct2);
        Future<Boolean> r3 = ser.submit(ct3);
        // 获取结果：
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        // 关闭服务
        ser.shutdownNow();
    }
}
// 下载器
class WebDownloader1{
    // 下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，Downloader出现问题");
        }
    }
}

并发问题简介

// 多个线程同时操作同一个对象
// 买火车票的例子
public class ThreadTest4 implements Runnable{

    // 票数
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");
        }
    }

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

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();
    }
}

结果：

小明拿到了第10张票
老师拿到了第8张票
黄牛党拿到了第9张票
黄牛党拿到了第7张票
小明拿到了第7张票
老师拿到了第7张票
黄牛党拿到了第6张票
…

可见发生了多个人取到同一张票

静态代理模式

静态代理模式总结：

  • 真实对象和代理对象都要实现同一个接口
  • 代理对象要代理真实角色

好处：
1.代理对象可以做很多真实对象做不了的事情
2.真实对象专注做自己的事情


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

        new Thread( ()-> System.out.println("我爱你") ).start();
        // Thread也实现了Runnable接口，所以代理了Runnable接口，Thread调用了start方法（Runnable接口只有run方法，Thread调用了start方法时虚拟机调用了run方法），
        // 相当于WeddingCompany代理了Marry，调用了HappyMarry方法
        new WeddingCompany(new You()).HappyMarry();;

    }
}


interface Marry{
    void HappyMarry();
}


// 真实角色，你。 你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚了，好开心");
    }
}


// 代理角色，婚庆公司。 帮助你办婚礼
class WeddingCompany implements Marry{
    // 代理谁-->真实目标角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这是真实对象
        after();
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }

    private void after() {
        System.out.println("办完婚礼后，付尾款");
    }
}

线程状态

线程停止（stop）

  • 建议线程正常停止（自己停下来）。即利用次数，不建议死循环
  • 建议使用标志位作为终止，当flag=false，则线程终止运行
  • 不要使用stop或者destroy等过时或不建议使用的方法

基本步骤：

  1. 线程中定义线程体使用的标识
  2. 线程体使用该标识
  3. 对外提供方法改变标识

例子：

public class TestStop implements Runnable{

    // 1.设置一个标志位
    private  boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread"+i++);
        }
    }

    // 2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

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

        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900) { // 主线程到i=900的时候才停止线程
                testStop.stop();
                System.out.println("线程停止了");
            }

        }
    }
}

输出：

…
main900
run…Thread662
线程停止了
main901
…

线程休眠（sleep）

  • sleep(毫秒) 指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后，线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等
  • 每一个对象都有一个锁，sleep不会释放锁

例子1：在前面的了解并发问题的买票例子中可以加入延时Thread.sleep(100);,从而模拟网络延迟，这样可以放大问题的发生性。

例子2：模拟倒计时。

public class Countdown {
    public static void main(String[] args) {
        try {
            countdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

//模拟倒计时
    public static void countdown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

例子3：打印当前系统时间


public class SystemTime {

        public static void main(String[] args) throws InterruptedException {
            //打印当前系统时间
            Date time = new Date(System.currentTimeMillis());//获取当前系统时间

            while(true){
                try {
                    Thread.sleep(1000);
                    System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));
                    time = new Date(System.currentTimeMillis());//更新当前时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

线程礼让（yield）

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 注意：让CPU重新调度，礼让不一定成功！看CPU心情
public class YieldTest {

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

        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
    }
}


class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

输出：（礼让不成功）

A线程开始执行
A线程停止执行
B线程开始执行
B线程停止执行

输出：（礼让成功）

A线程开始执行
B线程开始执行
A线程停止执行
B线程停止执行

线程强制执行（join）

  • join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞（可以想象成插队）
public class JoinTest implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 1000; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new JoinTest());
        thread.start();

        for (int i = 0; i < 500; i++) {
            if(i==200){
                thread.join();
                //主线程跑到200的时候插队,插队者跑完1000才继续其他的线程，包括主线程
            }
            System.out.println("main"+i);
        }
    }
}

线程状态观测

在这里插入图片描述

线程状态。 线程可以处于以下状态之一：

  • NEW 尚未启动的线程处于此状态。
  • RUNNABLE 在Java虚拟机中执行的线程处于此状态。
  • BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
  • WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED 已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

// 观察线程的状态
public class StateTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{

        for (int i = 0; i < 5; i++) {// 线程启动后睡五秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("干活！");
        });

        // 观察状态
        Thread.State state = thread.getState();
        System.out.println(state);// 观察new了一个线程后的状态


        // 观察启动后
        thread.start();// 启动线程
        state = thread.getState();
        System.out.println(state);// 观察线程run后的状态


        while(state!=Thread.State.TERMINATED){ // 只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();// 更新线程状态
            System.out.println(state);// 输出状态
        }
    }
}

输出：

NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
…
TIMED_WAITING
干活！
TERMINATED

【注意】线程start后不一定立即执行，而是处于RUNNABLE状态，即就绪状态。线程休眠的5秒钟内一直是TIMED_WAITING状态，睡醒之后就干活，干完活就线程终止

线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

  • 线程的优先级用数字表示，范围从1~10：（数字越大优先级越高）
    Thread.MIN_PRIORITY = 1;
    Thread.MAX_PRIORITY = 10;
    Thread.NORM_PRIORITY = 5;
    【注意】优先级低只是意味着获得调度的概率低。并不是优先级低就不会被先调用，这都是取决于CPU。

  • 使用以下方式改变或者获取优先级：
    getPriority()
    setPriority(int x)

  • 如果需要设置优先级，先设定好优先级再start()


// 测试线程的优先级
public class PriorityTest {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主线程优先级:"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        // 先设置优先级 再启动
        t1.start();

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

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

        t4.setPriority(Thread.MAX_PRIORITY);// MAX_PRIORITY=10
        t4.start();


    }
}


class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"优先级:"+Thread.currentThread().getPriority());
    }
}

守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 守护线程如：后台记录操作日志，监控内存，垃圾回收等
public class DaemonTest {
    public static void main(String[] args) {
        God god = new God();
        You1 you = new You1();

        Thread thread = new Thread(god);
        thread.setDaemon(true); // 默认是false，表示用户线程，一般都是用户线程

        thread.start();// 上帝守护线程启动

        new Thread(you).start();// 你 用户线程启动
    }
}


// 上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑你");
        }
    }
}


// 你
class You1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 36500; i++) {
            System.out.println("你一生幸福快乐地活着");
        }
        System.out.println("goodbye world");
    }
}

用户线程停止之后，守护线程还在运行，因为虚拟机停止需要一段时间。

后续内容见《Java学习笔记5-2》

Bug一号质检员
关注
JAVA多线程学习笔记整理（csdn）————程序.pdf
12-01
Java多线程是Java编程中的核心概念，它允许并发执行多个任务，提高程序的执行效率。以下是关于Java多线程的详细知识点： 1. **创建线程** - **继承Thread类**：创建一个新的类，该类继承自Thread类，并重写run()...
java多线程学习笔记02（csdn）————程序.pdf
12-01
在这个学习笔记中，主要讨论了Java中的线程同步机制，包括volatile关键字、synchronized以及Lock接口，特别是ReentrantLock的使用。 首先，对于线程1和线程2的疑惑，调试（debug）模式并不能改变线程的执行顺序。...
java基础（五）
anlaomei4040的博客
02-20 127
java基础（五） 命名规则： 名字中只能包含->字母、_、数字、$，且开头不能为数字包名必须都小写 文件名首字母和后面英文文件单词首字母都要大写 变量和方法名 首字母小写，后面英文单词首字母大写 java中的方法： java方法是语句的集合，他们在一起执行一个功能 方法是解决一类问题的步骤的有序组合 方法包含...
java 数组练习_java5-1 数组的练习
weixin_42298969的博客
02-15 311
1、 数组遍历：依次输出数组中的每一个元素[代码]java代码：0102030405060708091011121314151617public class ArrayText1 {public static void main(String[] args) {// TODO Auto-generated method stubint[] a = {1,2,3,4,5,6,7};f...
Java 5-1、用户模块-Mybatis代码生成
开发以大橘为重
01-21 594
5-1 用户模块-Mybatis代码生成 从这里开始，环境相关配置就告一段落了，项目就开始进入开发学习阶段。 一、代码生成 实体类、Mapper接口、Mapper xml 分别生成 AppUser.java、SysUser.java，再抽取BaseUser.java 修改AppUserMapper.xml定义的方法 tips：代码文件附在文末 二、新增注解 @EqualsAndHashCode(callSuper = true) @SuperBuilder(toBuilder = true) 注解于
java:5-1最小公倍数
Claire的博客
03-01 211
java:5-1最小公倍数 题目 问题描述 　　编写一函数lcm，求两个正整数的最小公倍数。 样例输入 一个满足题目要求的输入范例。 例： 3 5 样例输出 与上面的样例输入对应的输出。 数据规模和约定 　　输入数据中每一个数的范围。 　　例：两个数都小于65536。 import java.util.Scanner; public class 求最小公倍数 { public sta...
java5 for_java_5.1 for循环
weixin_32312889的博客
02-20 141
1.求1-100的和public static void main(String[] args) {int sum = 0;for (int i = 0; i <= 100 ; i++) {sum += i;}System.out.println(sum);}2.求1-100之间偶数和public static void main(String[] args) {int sum = 0;fo...
Java学习笔记---多线程并发
weixin_44823875的博客
03-22 1598
Java学习笔记---多线程并发认识线程和进程java中线程的实现继承Thread类（多线程实现类）实现Runnable接口（==推荐使用==）Thread类和Runnable接口线程的状态线程操作的方法同步与死锁使用同步解决使用死锁解决 认识线程和进程 进程是线程一次动态执行过程，它需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。因为每个进...
Java学习笔记（八）——多线程
weixin_44145894的博客
12-22 1330
创建线程的第一种方式：继承Thread类 步骤： ①定义类继承Thread ②复写Thread类中的run方法，目的：将自定义代码存储在run方法中，让线程运行 ③调用线程的start方法，该方法两个作用：启动线程，调用run方法 Thread为什么要覆盖run方法呢？ Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法，也就是说Thread类中的run方法，用于存储线程要运行的代码。 代码示例 class Test_thread extends
java学习笔记（8）——多线程
水寒
08-06 2190
进程：是一个程序在其自身的地址空间的一次执行活动。 线程：(区别于进程)线程没有独立的存储空间。 几个概念：时间片 线程  进程   能不能够用多进程代替多线程呢？ 两个进程切换时要交换内存空间，而多线程切换时效率比较高，所以通常多个任务采用多线程，不要开启大量的进程。 java在语言级别提供了对多线程程序设计的支持 实现多线程程序的两种方式： 1，从Thread类继承 2，实现R
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
JAVA学习笔记————————
04-25
在深入探讨JAVA学习笔记之前，我们首先理解一下JAVA这一编程语言的重要性。JAVA，由Sun Microsystems公司（现已被Oracle收购）于1995年推出，是一种面向对象的、跨平台的编程语言，以其“一次编写，到处运行”的特性...
javaNIO学习笔记（csdn）————程序.pdf
12-01
Java NIO，全称Non-Blocking Input/Output，是非阻塞式输入输出，它是Java从1.4版本开始引入的一种新的I/O模型，为Java程序员提供了处理I/O操作的新方式。NIO的主要特点是其能够使Java程序以更有效的方式处理I/O流，...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 809
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1370
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 861
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 249
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 407
函数式接口与回调函数
Java复习24（PTA)
2301_79272475的博客
10-30 407
Java复习24（PTA)：多种排序的book类*
Java关键字学习笔记——mars老师讲解
"mars老师的java4Android的学习笔记" Java是一种广泛使用的面向对象的编程语言，它以其强大、灵活和跨平台的特性而闻名。在Java中，关键字是具有特殊含义的保留词汇，它们不能作为变量、函数或其他标识符的名称。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值