2021年Java进阶篇(六)线程

最新推荐文章于 2024-07-13 22:56:10 发布
最新推荐文章于 2024-07-13 22:56:10 发布
阅读量99 收藏
点赞数
分类专栏： 进阶篇 笔记 个人学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/her_mia/article/details/116034868
版权
笔记 同时被 3 个专栏收录
15 篇文章 0 订阅
订阅专栏
个人学习
14 篇文章 0 订阅
订阅专栏
进阶篇
9 篇文章 0 订阅
订阅专栏

2021年Java进阶篇(六)线程

今天主要介绍线程

文章目录

前言

话不多说直接上干货

提示：以下是本篇文章正文内容，下面案例可供参考

一、多线程

我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？

这就是我们今天要介绍的东西了: 多线程

1.1 并发与并行

并发：指的是两个事情或多件事情在同一时间段内发生
并行：指的是两个或多个时间在同一时刻发生(同时发生)
在这里插入图片描述

1.2 进程和线程

进程：指的是一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程。进程也是程序的一次执行过程，是系统运行程序的基本单位。系统运行一个程序就是一个进程从创建、运行到消亡的过程。

线程：线程是进程中的一个执行单元，负责当前进行中程序的执行，一个进程至少要有一个线程。一个进程是可以有多个线程的，这样的程序也就被称之为多线程应用。

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

进程在这里插入图片描述

线程
在这里插入图片描述

线程调度：

  • 分时调度
    所有线程轮流使用CPU的使用权，平均分配每个线程占用CPD的时间
  • 抢占式调度
    优先让优先级高的线程使用CPU，如果线程的优先级相同，那么就会随机选择一个(线程的随机性)，Java使用的就是抢占式调度

设置线程的优先级
在这里插入图片描述
抢占式调度详解

大部分的操作系统都支持多线程并发执行，现在操作系统几乎都支持同时运行多个程序。

实际上，CPU使用抢占式调度模式在多个线程之间进行着告诉切换。对于CPU的一个核来说，某个时刻只能执行一个线程，而CPU在多个线程之间切换速度相对我们来说很快的是，所以看起来像是在同一时刻一起运行的。

在这里插入图片描述

1.3 创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或者其子类的示例。每个线程的作用就是完成一定的任务，实际上就是执行一段时间流也就是一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象。
  3. 调用线程对象的start()方法来创建该线程。
// 测试类
public class Demo01 {
	public static void main(String[] args) {
		//创建自定义线程对象
		MyThread mt = new MyThread("新的线程！");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
	}
}

// 自定义线程类

public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}

二、线程

2.1 多线程原理


// 线程类
public class MyThread extends Thread{
	/*
	* 利用继承中的特点
	* 将线程名称传递 进行设置
	*/
	public MyThread(String name){
		super(name);
	}
		/*
		* 重写run方法
		* 定义线程要执行的代码
		*/
	public void run(){
		for (int i = 0; i < 20; i++) {
			//getName()方法 来自父亲
			System.out.println(getName()+i);
		}
	}
}

// 测试类
public class Demo {
	public static void main(String[] args) {
		System.out.println("这里是main线程");
		MyThread mt = new MyThread("小强");
		mt.start();//开启了一个新的线程
		for (int i = 0; i < 20; i++) {
			System.out.println("旺财:"+i);
		}
	}
}

流程图
在这里插入图片描述

程序启动运行main的时候，JVM启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另一个新线程也启动了，这样整个英语就在多线程下运行。

说完了流程图我们来说一下原理吧！

在这里插入图片描述
当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了。那么线程就结束了。

2.2 Thread类

Thread类的一些方法

构造方法

public Thread():分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法

public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

2.3 创建线程的方式

在上面我们使用了继承Thread类的方法创建多线程程序，这里我们使用另一种创建的方法

采用java.lang.Runnable是一种很常见的方式，我们只需要重写run方法即可

操作步骤

  1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  3. 调用线程对象的start()方法来启动线程
public class MyRunnable implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}


public class Demo {
	public static void main(String[] args) {
		//创建自定义类对象 线程任务对象
		MyRunnable mr = new MyRunnable();
		//创建线程对象
		Thread t = new Thread(mr, "小强");
		t.start();
		for (int i = 0; i < 20; i++) {
			System.out.println("旺财 " + i);
		}
	}
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现类Runnable接口的类。

在启动多线程程序的时候，首先需要通过Thread类的构造方法Thread(Runnable target)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过Thread的start()方法来执行的，因此不管是继承Thread类还是实现了Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API时进行多线程编程的基础哦~

tips:

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。

而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

2.4 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是实现了Runnable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势

  1. 适合多个相同的程序代码的线程去共享同一个资源
  2. 可以避免Java中的单继承的局限性
  3. 增加线程的健壮性，实现解耦的操作，代码可以被多个线程共享，代码和线程独立。
  4. 线程池只能放入实现Runnable和Callable类线程，不能直接放入继承Thread的类。

在Java中每次程序运行至少会启动2个线程，一个是main线程，一个是垃圾回收线程。因此每当使用Java命令执行一个类的适合，实际都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程。

2.5 匿名内部类的方式实现线程的创建

public class NoNameInnerClassThread {
public static void main(String[] args) {
	Runnable r = new Runnable(){
		public void run(){
			for (int i = 0; i < 20; i++) {
				System.out.println("张宇:"+i);
			}
		}
	};
	new Thread(r).start();
		for (int i = 0; i < 20; i++) {
			System.out.println("费玉清:"+i);
		}
	}
}

三、线程安全

3.1 线程安全

如果有多个线程同时在执行，而这些线程可能会在同时运行同一段代码。程序每次运行结果和单线程运行的结果是一模一样的，而且其他的变量的值也是和预期的一样，那就说明是线程安全的。

举个栗子(我原称之为线程安全栗子之经典！！！)

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个 (本场电影只能卖100张票)

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)

需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

// 模拟票
public class Ticket implements Runnable {
	private int ticket = 100;
	/*
	* 执行卖票操作
	*/
	@Override
	public void run() {
		//每个窗口卖票的操作
		//窗口 永远开启
		while (true) {
			if (ticket > 0) {//有票 可以卖
				//出票操作
				//使用sleep模拟一下出票时间
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto‐generated catch block
					e.printStackTrace();
				}
				//获取当前线程对象的名字
				String name = Thread.currentThread().getName();
				System.out.println(name + "正在卖:" + ticket‐‐);
			}
		}
	}
}

// 测试类
public class Demo {
	public static void main(String[] args) {
		//创建线程任务对象
		Ticket ticket = new Ticket();
		//创建三个窗口对象
		Thread t1 = new Thread(ticket, "窗口1");
		Thread t2 = new Thread(ticket, "窗口2");
		Thread t3 = new Thread(ticket, "窗口3");
		//同时卖票
		t1.start();
		t2.start();
		t3.start();
	}
}

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

看！！！出问题了！！！

  1. 相同的票数，比如5这张票被卖了两次
  2. 不存在的票，比如0和-1是不存在的票

这样的问题，几个窗口(线程)票数不同步了，这就称之为线程不安全。
线程安全问题都是由全局变量以及静态变量引起的。如果每个线程中对全局变量、静态变量都有读操作，而无写操作，一般来说这个线程是安全的。如果多个线程同时执行写操作，一般就需要考虑线程同步，不然的话就可能影响线程安全。

3.2 线程同步

当我们使用多个线程访问统一资源的适合，而且多个线程中对资源有写的操作，就容易出现线程安全问题。

需要解决上述线程并发访问一个资源的安全性的问题，Java中提供了同步机制(synchronized)来解决。

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制

在Java中有三种方式来完成同步操作。

  1. 同步代码块
  2. 同步方法
  3. 锁机制

3.3 同步代码块

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

synchronized(同步锁){
	需要同步操作的代码
}

同步锁

对象的同步锁只是一个概念，可以想象成在对象身上标记了一个锁

  1. 锁对象，可以是任意的类型
  2. 多个线程对象，需要使用同一把锁
  3. 在任何适合，最多允许有一个线程拥有同步锁，随拿到所就进入代码块，其他线程只能在外等着
public class Ticket implements Runnable{
	private int ticket = 100;
	Object lock = new Object();
	/*
	* 执行卖票操作
	*/
	@Override
	public void run() {
		//每个窗口卖票的操作
		//窗口 永远开启
		while(true){
			synchronized (lock) {
			if(ticket>0){//有票 可以卖
				//出票操作
				//使用sleep模拟一下出票时间
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					// TODO Auto‐generated catch block
					e.printStackTrace();
				}
					//获取当前线程对象的名字
					String name = Thread.currentThread().getName();
					System.out.println(name+"正在卖:"+ticket‐‐);
				}
			}
		}
	}
}

// 当使用了同步代码块之后，上述的线程问题就解决了

3.4 同步方法

使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候其他线程只能在方法外面等着

public synchronized void method(){
	可能会产生线程安全问题的代码
}

同步锁是谁？
对于非static方法，同步锁就是this。

对于static方法，我们使用当前方法所在类的字节码对象(类名.class)

public class Ticket implements Runnable{
	private int ticket = 100;
	/*
	* 执行卖票操作
	*/
	@Override
	public void run() {
		//每个窗口卖票的操作
		//窗口 永远开启
		while(true){
		sellTicket();
		}
	}
		/*
		* 锁对象 是 谁调用这个方法 就是谁
		* 隐含 锁对象 就是 this
		*
		*/
	public synchronized void sellTicket(){
		if(ticket>0){//有票 可以卖
			//出票操作
			//使用sleep模拟一下出票时间
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto‐generated catch block
				e.printStackTrace();
			}
			//获取当前线程对象的名字
			String name = Thread.currentThread().getName();
			System.out.println(name+"正在卖:"+ticket‐‐);
		}
	}
}

3.5 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更加广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更加强大，更加体现面向对象

Lock锁也被称为同步锁，加锁与释放锁方法化了
public void lock() 加同步锁
public void unlock() 释放同步锁

public class Ticket implements Runnable{
	private int ticket = 100;
	Lock lock = new ReentrantLock();
	/*
	* 执行卖票操作
	*/
	@Override
	public void run() {
		//每个窗口卖票的操作
		//窗口 永远开启
		while(true){
		lock.lock();
		if(ticket>0){//有票 可以卖
			//出票操作
			//使用sleep模拟一下出票时间
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				// TODO Auto‐generated catch block
				e.printStackTrace();
			}
			//获取当前线程对象的名字
			String name = Thread.currentThread().getName();
			System.out.println(name+"正在卖:"+ticket‐‐);
			}
		lock.unlock();
		}
	}
}

四、线程状态

4.1 线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中一共有六种状态。这六种状态在java.lang.Thread.State这个枚举类种都给出了
在这里插入图片描述

4.2 Time Waiting（计时等待）

Time Waiting在API中的描述为：一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。

在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法里面添加了sleep语句，这样就强制当前正在执行的线程休眠(暂停执行)，以缓慢线程。

当我们在调用了sleep方法之后，当前执行的线程就进入到了休眠状态，其实就是所谓的Timed Waiting(计时等待)

public class MyThread extends Thread {
	public void run() {
	for (int i = 0; i < 100; i++) {
		if ((i) % 10 == 0) {
			System.out.println("‐‐‐‐‐‐‐" + i);
			}
			System.out.print(i);
			try {
			Thread.sleep(1000);
				System.out.print(" 线程睡眠1秒！\n");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		new MyThread().start();
	}
}

通过上面的代码就可以看出来，sleep方法的使用是很简单的。我们只需要记住下面几点

  1. 进入 TIMED_WAITING 状态的一种常见情形就是调用sleep方法，单独的线程也可以调用的，不一定非要有协作关系。
  2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。
  3. sleep与锁无关，线程睡眠到期会自动苏醒，并返回到Runnable状态。

Timed Waiting 线程状态图

在这里插入图片描述

4.3 BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁(锁对象)的线程处于这一状态。

Blocked 线程状态图
在这里插入图片描述

4.4 Waiting (无限等待)

Waiting状态在API中介绍为：一个正在无期限等待另一个线程执行特别的(唤醒)动作的线程处于这一状态

public class WaitingTest {
	public static Object obj = new Object();
	public static void main(String[] args) {
		// 演示waiting
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true){
				synchronized (obj){
					try {
						System.out.println( Thread.currentThread().getName() +"=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象");
						obj.wait(); //无限等待
						//obj.wait(5000); //计时等待, 5秒 时间到，自动醒来
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
						System.out.println( Thread.currentThread().getName() + "=== 从waiting状态醒来，获取到锁对象，继续执行了");
					}
				}
			}
		},"等待线程").start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				// while (true){ //每隔3秒 唤醒一次
				try {
					System.out.println( Thread.currentThread().getName() +"‐‐‐‐‐ 等待3秒钟");
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (obj){
					System.out.println( Thread.currentThread().getName() +"‐‐‐‐‐ 获取到锁对象,调用notify方法，释放锁对象");
					obj.notify();
				}
			}
		},"唤醒线程").start();
	}
}

通过上述案例我们会发现，一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法 或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

Waiting 线程状态图
在这里插入图片描述

一个各种状态都有图片(但是很重要)
在这里插入图片描述

总结

今天的分享到这里就结束了，如果觉得写的还不错的话可以多多关注点赞转发哦，本系列会持续更新!!!

zhangyuxin0326
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java0316:巨匠java进阶2021
03-16
【Java0316:巨匠java进阶2021】这个压缩包文件名暗示了这是一份关于Java编程语言的高级学习资料，可能是2021年更新的课程或者教程。根据“巨匠”这个词，我们可以推测这是一套由资深专家或知名教师编撰的教程，旨在...
BurpSuite2021 -- Intruder模块
weixin_41489908的博客
06-13 5365
​真正爱上一个人的感觉，就是别人再好与我无关，承蒙你的出现，足够让我欢喜一辈子。。。 ---- 网易云热评 一、Target，目标，当我们抓到数据包，右击发送到Intruder模块，这里会自动填写好信息 二、设置爆破模式即参数 1、Sniper:对变量进行依次破解，只有一个字典 2、Battering ran:对变量进行同时破解，用户名和密码相同，只有一个字典 3、pitch fork:每个变量将会对应一个字典，用户名和密码一一对应，两个字典 4、Cluster bomb:每个变.
Java多线程相关的几十个问题
YunWisdom
12-27 687
转载来源：http://www.cnblogs.com/HadesFX/p/5333810.html ， https://www.cnblogs.com/HadesFX/p/5333820.html   Java多线程相关的几个问题   1、多线程有什么用？ 一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓"知其然知其所以然"，"会...
2021年春java大作业.zip
06-15
此外，笔记中可能还会涉及异常处理、线程、集合框架（List、Set、Map）以及IO流等内容，这些都是Java进阶时会遇到的重要主题。 复习巩固部分可能包含各种练习题和解决方案，帮助学生检验自己的理解并提升编程技能。...
JAVA基础编程练习题50题及经典算法90题+2021年Java高进进阶面试题【含源码及答案】.rar
09-10
再者，2021年Java高进进阶面试题是针对有一定经验的开发者设计的，这些题目可能涉及到多线程、并发编程、JVM内存模型、Spring框架、设计模式、数据库操作等高级主题。对于准备面试或者寻求技术突破的程序员来说，...
2021年JAVA核心知识点整理.rar
06-18
以上是"2021年JAVA核心知识点整理.rar"压缩包中所涵盖的主要内容，这些知识点构成了Java开发者必备的基础和进阶技能。深入理解和掌握这些知识点，能够帮助开发者编写更高效、更可靠的代码，更好地应对各种软件开发...
2021_Java_Interview:2021年Java开发岗知识积累
03-17
以上是根据"2021_Java_Interview:2021年Java开发岗知识积累"这个主题所涵盖的Java开发者应知应会的知识点。通过深入学习这些内容，不仅可以为面试做好充分准备，也能在实际工作中提升开发能力。
Elsaticsearch java基本操作
qq_62383709的博客
07-13 313
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
配置Java开发环境
Broken_x的博客
07-10 1465
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 363
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 431
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2347
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1429
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 554
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 264
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3322
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
Java 线程池详解
最新发布
qq_41591215的博客
07-13 448
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 760
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 335
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。
java快速学习笔记（已有基础）
11-02
笔记内容主要包括线程和文件操作，同时也涵盖了Java中基本类型与String之间的转换、可变参数的使用、继承以及多态等核心概念。" 在Java编程中，基本类型与String类型的转换是一个常见的需求。例如，将String类型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值