【JavaEE初阶】Thread 类及常见方法、线程的状态

已于 2023-11-24 18:00:18 修改
阅读量1.4k 收藏 31
点赞数 26
分类专栏： JavaEE 文章标签： java-ee java
于 2023-11-24 17:11:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61876562/article/details/134583641
版权
本文详细介绍了Java中的Thread类，包括其构造方法、常用属性（如状态、优先级、中断标志等）、启动线程(start)、中断线程(interrupt)、等待线程(join)以及线程状态的观察和转移。通过实例展示了如何控制线程行为和理解线程状态在程序中的作用。
摘要由CSDN通过智能技术生成

目录

1、Thread 类及常见方法

1.1 Thread 的常见构造方法

1.2 Thread 的几个常见属性

1.3 启动⼀个线程 - start()  

1.4 中断⼀个线程  

 1.5 等待⼀个线程 - join()

1.6 获取当前线程引用

1.7 休眠当前线程

2、线程的状态 

2.1 观察线程的所有状态 

2.2 线程状态和状态转移的意义 

2.3 观察线程的状态和转移

1、Thread 类及常见方法

Thread 类是 JVM 用来管理线程的⼀个类，换句话说，每个线程都有⼀个唯⼀的 Thread 对象与之关联。
每个执行流，也需要有⼀个对象来描述，类似下图所示，Thread 类的对象 就是用来描述⼀个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理。

1.1 Thread 的常见构造方法

 

代码示例：

Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

1.2 Thread 的几个常见属性

 

  • ID 是线程的唯⼀标识，不同线程不会重复，是JVM自动分配的身份标识
  • 名称是各种调试工具用到
  • 状态表示线程当前所处的⼀个情况，下面我们会进⼀步说明
  • 优先级高的线程理论上来说更容易被调度到
  • 关于后台线程，需要记住⼀点：JVM会在⼀个进程的所有⾮后台线程结束后，才会结束运⾏。

补充：

前台线程的运行会阻止进程的结束；后台线程的运行不会阻止进程的结束。

咱们代码创建的线程，默认就是前台线程，会阻止进程的结束，只要前台线程没执行完，进程就不会结束，即使main已经执行完毕了。

代码举例：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t= new Thread(()->{
            for (int i = 0;i < 10;i++) {
                System.out.println("线程工作");
                try{
                    Thread.sleep(3000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

分析这个代码，当执行到t.start()时，会创建一个新的线程，新的线程去执行循环，而main线程继续自己的后续代码的执行，此时后面已没有代码，则main线程执行完毕，可以通过jonsole工具进行查看，如图：

按照我们之前的理解，main执行完毕，进程就应该结束，但是很明显，该进程依然继续执行，我们可以根据上述代码的运行结果来看：

若我们把 t 线程设为后台线程，结果又是如何呢？

设为后台线程的代码：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread t= new Thread(()->{
            for (int i = 0;i < 10;i++) {
                System.out.println("线程工作");
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.setDaemon(true);
        t.start();
    }
}

这时的运行结果如图，可知当线程 t 设为后台线程就不会阻止进程的结束了，当main执行完毕，进程就直接结束了。

  • 是否存活，即简单的理解为 run 方法是否运行结束了

补充：

isAlive()该方法表示了内核中的线程（PCB）是否还存在。

java代码中定义的线程对象（Thread）实例，虽然表示一个线程，但这个对象本身的生命周期与内核中的线程PCB生命周期是不完全一样的。

  1. 当实例化完一个对象 t 时，此时 t 对象有了，但内核pcb还没有创建，所以此时isAlive()是false的。
  2. 当执行完 t.start() ，这时就真正在内核中创建出pcb，此时isAlive()的值就是true了。
  3. 当线程run执行完了，此时内核中的线程就结束了（内核pcb就释放了），但是t对象可能还存在，isAlive()的值仍是false。
  • 线程的中断问题，下面我们进⼀步说明

下面是代码示例：

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ": 我还活着");
                            Thread.sleep(1 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + ": 我即将死去");
        });
        System.out.println(Thread.currentThread().getName()
                + ": ID: " + thread.getId());
        System.out.println(Thread.currentThread().getName()
                + ": 名称: " + thread.getName());
        System.out.println(Thread.currentThread().getName()
                + ": 状态: " + thread.getState());
        System.out.println(Thread.currentThread().getName()
                + ": 优先级: " + thread.getPriority());
        System.out.println(Thread.currentThread().getName()
                + ": 后台线程: " + thread.isDaemon());
        System.out.println(Thread.currentThread().getName()
                + ": 活着: " + thread.isAlive());
        System.out.println(Thread.currentThread().getName()
                + ": 被中断: " + thread.isInterrupted());
        thread.start();
        while (thread.isAlive()) {}
        System.out.println(Thread.currentThread().getName()
                + ": 状态: " + thread.getState());
    }
}

运行结果：

1.3 启动⼀个线程 - start()  

之前我们已经看到了如何通过覆写 run 方法创建⼀个线程对象，但线程对象被创建出来并不意味着线 程就开始运行了。
  • 覆写 run 方法是提供给线程要做的事情的指令清单
  • 线程对象可以认为是把 李四、王五叫过来了
  • 而调用 start()方法，就是喊⼀声：“行动起来！”，线程才真正独立去执行了

 

调用 start 方法, 才真的在操作系统的底层创建出⼀个线程.  对于同一个Thread对象来说，start只能调用一次。

经典面试题：start 和 run 的区别

用一个代码来说明：

class MyThread8 extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo8 {
    public static void main(String[] args) {
        Thread t = new MyThread8();
        //t.run();   //此时是main方法调用run，没有创建新线程，后续的循环执行不到
        t.start();  //会创建新的线程，新线程执行run的循环，主线程main继续后续代码
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

当创建一个Thread类对象 t 时：

由 t 调用run方法时（ t.run() )，并没有创建出一个新的线程，这个操作还是在主线程main中进行的，循环打印hello，此时代码就只能停留在run的循环中了，下方main中的循环执行不到。

若由 t 调用start，这时会创建出一个新的线程，去执行run循环；main线程则继续执行自己的后续循环。

总结：

作用功能不同：

  1. run方法的作用是描述线程具体要执行的任务；
  2. start方法的作用是真正的去申请系统线程

运行结果不同：

  1. run方法是一个类中的普通方法，主动调用和调用普通方法一样，会顺序执行一次；
  2. start调用方法后, start方法内部会调用Java 本地方法（封装了对系统底层的调用）真正的启动线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段。

1.4 中断⼀个线程  

接着上面图片张三、李四的例子，李四⼀旦进到工作状态，他就会按照行动指南上的步骤去进行工作，不完成是不会结束的。但有时我们需要增加⼀些机制，例如老板突然来电话了，说转账的对方是个骗子，需要赶紧停⽌转账，那张三该如何通知李四停止呢？这就涉及到我们的停⽌线程的方式了。

目前常见的有以下两种方式：
  1. 通过共享的标记来进行沟通
  2. 调用 interrupt() 方法来通知

示例1: 使用自定义的变量来作为标志位，示例代码：

public class ThreadDemo9 {
    private static boolean isQuit = false;
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (!isQuit) {
                System.out.println("hello");
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t结束");
        });
        t.start();

        try {
            Thread.sleep(3000);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("让t线程结束");
        isQuit = true;
    }
}

运行结果：

我们可以看到代码中，将自定义的变量标志位写成了类的静态成员变量，那是否可以写为main方法中的局部变量？

不可以！ 当你定义为局部变量时，会发现提示编译错误。

这是因为我们使用了创建线程的lambda表达式方法，lambda表达式有一个语法：变量捕获。

lambda表达式的变量捕获，本质上就是，把外面的变量当作参数传进来（参数是隐藏的）。这个捕获的变量得是 final 修饰的或者“事实final”（虽然没有写final，但是没有修改）。因为此处isQuit是确实要修改的，不能写成final，它也不是事实final,因此将标志位变量isQuit定义为局部变量是行不通的！

那为什么可以定义为成员变量呢？

lambda表达式，本质上是“函数式接口”，匿名内部类。对于内部类，访问外部类的成员是完全可以的，这个事情不受到变量捕获的影响。

示例2: 使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位。
Thread 内部包含了⼀个 boolean 类型的变量作为线程是否被中断的标记。

示例代码：

public static void main(String[] args) {
        Thread t = new Thread(()->{
           while (!Thread.currentThread().isInterrupted()) {
               System.out.println("我是一个线程，正在工作");

               //interrupt会影响sleep,线程不会结束
                 try {
                    Thread.sleep(1000);
                }catch (InterruptedException e) {
                   e.printStackTrace();
                 }
              
           }
            System.out.println("线程结束");
        });

        t.start();
        try {
            Thread.sleep(3000);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("让t线程结束");
        t.interrupt();
    }
}

 运行结果：

可以看到抛出异常，并且线程不会结束，继续往下循环输出。这是因为什么呢？

这是因为存在sleep，在执行sleep的过程中，调用interrupt。大概率sleep休眠时间还没到，被提前唤醒了。

sleep被提前唤醒，会做两件事：

  1. 抛出InterruptedException，紧接着就会被catch捕获到
  2. 清除Thread对象的isInterrupted标志位

对于线程不会结束，就是标志位被清除了。我们通过interrupt方法，已经把标志位设为true了，但是sleep提前唤醒操作，又把标志位清除，设为原来的false，所以线程不会结束。

如何解决呢？

要想线程结束，只需要在catch中加上break即可。但此时仍会抛异常，不想抛，就不写输出e.printStackTrace()。

Thread t = new Thread(()->{
           while (!Thread.currentThread().isInterrupted()) {
               System.out.println("我是一个线程，正在工作");
               try {
                  Thread.sleep(1000);
               }catch (InterruptedException e) {
                  // e.printStackTrace();
                   break;  //加上break，仍会抛异常（不想抛，就不写上面输出e.printStackTrace()），线程会结束
              }
           }
            System.out.println("线程执行完毕");
        });

这时的结果：

thread 收到通知的方式有两种：
  1. 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，并清除中断标志。当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法，可以选择忽略这个异常，也可以跳出循环结束线程。
  2. 否则，只是内部的⼀个中断标志被设置，thread 可以通过 Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志。这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

 1.5 等待⼀个线程 - join()

有时，我们需要等待⼀个线程完成它的⼯作后，才能进行自己的下⼀步工作。例如，张三只有等李四转账成功，才决定是否存钱，这时我们需要⼀个方法明确等待线程的结束。

代码示例：

public class ThreadDemo {
 public static void main(String[] args) throws InterruptedException {
     Runnable target = () -> {
         for (int i = 0; i < 10; i++) {
         try {
             System.out.println(Thread.currentThread().getName() 
         + ": 我还在⼯作！");
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
         System.out.println(Thread.currentThread().getName() + ": 我结束了！")
    };

    Thread thread1 = new Thread(target, "李四");
    Thread thread2 = new Thread(target, "王五");
    System.out.println("先让李四开始⼯作");
    thread1.start();
    thread1.join();
    System.out.println("李四⼯作结束了，让王五开始⼯作");
    thread2.start();
    thread2.join();
    System.out.println("王五⼯作结束了");
 }
}

 这里是几个join方法：

1.6 获取当前线程引用

 

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
    }
}

1.7 休眠当前线程

也是我们比较熟悉⼀组方法，有⼀点要记得，因为线程的调度是不可控的，所以，这个方法只能保证 实际休眠时间是大于等于参数设置的休眠时间的。

 

public class ThreadDemo {
     public static void main(String[] args) throws InterruptedException {
         System.out.println(System.currentTimeMillis());
         Thread.sleep(3 * 1000);
         System.out.println(System.currentTimeMillis());
     }
}

2、线程的状态 

2.1 观察线程的所有状态 

 线程的状态是⼀个枚举类型 Thread.State.

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}
  • NEW: 安排了工作, 还未开始行动
  • RUNNABLE: 可工作的，又可以分成正在⼯作中和即将开始⼯作.
  • BLOCKED: 这几个都表示排队等着其他事情
  • WAITING: 这几个都表示排队等着其他事情
  • TIMED_WAITING: 这几个都表示排队等着其他事情
  • TERMINATED: 工作完成了.

2.2 线程状态和状态转移的意义 

大家不要被这个状态转移图吓到，我们重点是要理解状态的意义以及各个状态的具体意思。  

还是我们之前的例子：
刚把李四、王五找来，还是给他们在安排任务，没让他们行动起来，就是 NEW 状态；
当李四、王五开始去窗口排队，等待服务，就进⼊到 RUNNABLE 状态。该状态并不表示已经被银行 工作人员开始接待，排在队伍中也是属于该状态，即可被服务的状态，是否开始服务，则看调度器的调度;
当李四、王五因为⼀些事情需要去忙，例如需要填写信息、回家取证件、发呆⼀会等等时，进⼊
BLOCKED 、 WATING 、 TIMED_WAITING 状态；
如果李四、王五已经忙完，为 TERMINATED 状态。
所以，我们上面内容介绍的 isAlive() 方法，可以认为是 处于不是 NEW 和 TERMINATED 的状态都是活着的。

2.3 观察线程的状态和转移

 观察 1: 关注 NEW 、 RUNNABLE 、 TERMINATED 状态的转换

public class ThreadStateTransfer {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 1000_0000; i++) {}
        }, "李四");
        System.out.println(t.getName() + ": " + t.getState());;
        t.start();
        while (t.isAlive()) {
            System.out.println(t.getName() + ": " + t.getState());;
        }
        System.out.println(t.getName() + ": " + t.getState());;
    }
}

观察 2: 关注 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换

public static void main(String[] args) {
    final Object object = new Object();
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (object) {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        }, "t1");
    t1.start();
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (object) {
                System.out.println("hehe");
            }
        }}, "t2");
    t2.start();
}
使⽤ jconsole 可以看到 t1 的状态是 TIMED_WAITING , t2 的状态是 BLOCKED
修改上面的代码, 把 t1 中的 sleep 换成 wait 
public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    try {
                        // [修改这⾥就可以了!!!!!]
                        // Thread.sleep(1000);
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1");
 ...
    }

使用户jconsole 可以看到 t1 的状态是 WAITING。

结论：
  • BLOCKED 表示等待获取锁，WAITING 和 TIMED_WAITING 表示等待其他线程发来通知.
  • TIMED_WAITING 线程在等待唤醒，但设置了时限； WAITING 线程在无限等待唤醒

【JavaEE初阶】Thread类及常见方法
2301_81510374的博客
07-24 912
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。每个执行流，也需要有一个对象来描述，类似下图所示，而 Thread 类的对象就是用来描述一个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理​。
【JavaEE初阶二】 Thread类及常见方法
2202_76101487的博客
12-26 2219
本篇内容主要讲解了thread类及相关方法
【后端开发】JavaEE初阶—Theard类及常见方法—线程的操作（超详解）
GGBond778的博客
09-22 2559
本期讲解了关于线程的某些重要属性和方法，例如线程的启动，终止，等待以及常见的属性的获取方法和构造方法，并附上代码供小伙伴们参考
【JavaEE初阶】 Thread类及常见方法
m0_71731682的博客
10-08 867
Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关联。每个执行流，也需要有一个对象来描述，类似下图所示，而 Thread 类的对象就是用来描述一个线程执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度，线程管理 使用如下： 命名操作：比如有以下程序： 当我们用 jconsole 命令进行查看时，结果如下： 上面就会有我们自己的命名。这样方便程序猿进行调试 常见属性说明：ID 是线程的唯一标识，不同线程不会重复名称是各种调试工具用
【JavaEE初阶 — 多线程】Thread类的方法＆线程生命周期
2402_84916296的博客
11-03 1065
【JavaEE初阶 — 多线程】Thread类的方法 在引出通过共享标志结束线程时，重点介绍了关于 lamda 表达式 的变量捕获问题； Java中线程生命周期的转台及其转移问题； sleep() 释放CPU 资源问题 inturrupt()除了设置 boolean变量(标志位)之外，还能够唤醒像 sleep 这样的阻塞方法 当前休眠线程，会因为能被inturrupt()提前唤醒而抛出异常，并且sleep()在 被提前唤醒，抛异常后，回修改线程原本的boolean变量（标志位）
JavaEE初阶—Thread类及常见方法—线程的操作
小蜗牛的珍贵百宝箱
10-09 428
Thread类是 Java 中用于创建和管理线程的基本类。通过继承Thread类或实现Runnable接口，开发者可以定义线程的执行逻辑。本文详细讲解了 JavaEE 中Thread类的基础知识、常用方法、线程的创建与管理，以及线程池的使用。通过合理的多线程管理，可以显著提高应用程序的性能。希望本文能帮助你在 JavaEE 的后端开发中更好地使用线程。如需深入学习，请参考Java 官方文档和相关的多线程编程书籍。
【JavaEE初阶】多线程 _ 基础篇 _ Thread类的使用、线程的几个重要操作和状态
热门推荐
哎呀是小张啊 的博客
08-10 1万+
这篇博客 介绍关于多线程基础篇的知识：Thread类 的常见构造方法和属性、和线程相关的几个重要操作 以及 Java 线程中的几种状态~
【JavaEE初阶】第四节.多线程基础篇 Thread类的使用、线程的几个重要操作和状态
未央的博客哟
01-19 6421
今天我们将进入到Java线程的基础篇中有关Thread类的使用、线程的几个重要操作和状态的学习，本节内容和上一节内容息息相关，请连贯的进行学习！！！！！
【JavaEE 初阶（一）】初识线程
weixin_69049913的博客
05-04 1374
本篇文章主要介绍了线程的概念，为什么要引入线程，要理解线程和进程的区别，创建线程的几种方法，会运用Thread的一些常见方法。
【JavaEE】多线程(二)Thread 类及常见方法
冲击大厂之路!!!
12-20 1121
Thread类再剖析！，Thread 类及常见方法。
Java学习资料 包括Javaee初阶，web前端，javascript,线程 Spring全家桶等等这些代码
06-21
Java提供了一套完整的线程API，包括Thread类、Runnable接口以及各种同步机制，如synchronized关键字、wait/notify、Lock接口等。 网络编程是Java学习的重要部分，涉及到套接字（Socket）、输入/输出流（InputStream...
笔记14-JAVAEE之多线程初阶
12-16
【JavaEE之多线程初阶】 在JavaEE开发中，多线程是提升系统性能和并发处理能力的重要手段。本文将深入探讨多线程的基本概念、应用以及关键特性。 1. **认识线程（Thread）** 1.1 概念 - **线程是什么**：线程被...
线程与进程的区别及线程实现（JavaEE初阶）
wjianwei666的专栏
06-08 377
进程具有独立性，导致系统十分的稳定。但是线程不一样，多个线程共用一份地址空间，一旦某个线程出 bug，很可能会导致整个进程受到牵连，异常结束，所以多个线程之间容易相互影响。这里不可以吧 flag 设置成局部变量，因为变量捕捉的缘故，设置成局部变量的话，如果说 flag 之后要改变就捕捉不到，除非把 flag 设置成 final 修饰的常量。System.out.println("t1 结束了!System.out.println("t2 结束了!System.out.println("线程结束!
【JavaEE进阶】导读
2401_83227065的博客
11-08 781
随着技术的发展, ⽆论是后端开发还是前端开发, 开发的时候都很少使⽤原⽣的代码，⽐如：JDBC、JS 等. 取⽽代之的是各种开发框架. 如：后端框架：Spring, SpringBoot, Mybatis等，前端常⽤的框架： Vue、Node等. 这些框架都有⼀个共同的特点, 就是简单, ⾼效. 这极⼤的提⾼了我们的开发效率. 那什么是框架呢?通俗的来讲: 框架是实现某种功能的半成品, 他提供了⼀些常⽤的⼯具类, 我们在框架的基础上, 可以更加⾼效的进⾏开发.
【JavaEE】认识进程
m0_74270127的博客
11-06 801
操作系统，进程，PCB，进程调度，并行执行与并发执行
【基于轻量型架构的WEB开发】课程 12.4 页面跳转 Java EE企业级应用开发教程 Spring+SpringMVC+MyBatis
Kika写代码的博客
11-05 692
由两图所示的控制台打印信息，以及跳转的页面信息可以看出，访问地址后执行了showPageByRequest()方法，方法执行后HttpServletRequest中的username转发到register.jsp页面中。由两图所示的控制台打印信息，以及跳转的页面信息可以看出，访问地址后执行了showPageByModel()方法，方法执行后，Model中的username和user对象转发到register.jsp页面。除了这种默认的转发方式，还可以返回指定前缀的字符串，来设定处理器执行后对请求进行。
【基于轻量型架构的WEB开发】课程 12.5 数据回写 Java EE企业级应用开发教程 Spring+SpringMVC+MyBatis
Kika写代码的博客
11-05 681
项目中已经导入了Jackson依赖，可以先调用Jackson的JSON转换的相关方法，将对象或集合转换成JSON数据，然后通过HttpServletResponse将JSON数据写入到输出流中完成回写，具体步骤如下。由图中所示的内容可以得出，访问地址后，执行了showDataByResponse()方法，方法执行后将普通字符串通过HttpServletResponse输出到请求页面中，完成了普通字符串的数据回写。由图中所示的内容可以得出，单击上图所示的“添加多个商品”按钮，程序成功回写了List对应的。
《JavaEE进阶》----20.＜基于Spring图书管理系统①（登录+添加图书）＞
最新发布
m0_73456341的博客
11-08 844
基于SpringWeb实现的图书管理系统，本篇文章详细讲解实现登录页面和添加图书功能。
spring循环依赖解决方式
qq_36400213的博客
11-04 937
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JavaEE项目实现分类方法研究
资源摘要信息: 本压缩包包含了一个JavaEE项目，该项目采用了分类方法作为关键技术手段。JavaEE（Java Platform, Enterprise Edition），又称Java Platform, Enterprise Edition或Java EE，是Sun Microsystems公司...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值