Thread thread = new Thread(futureTask);
thread.setName(“demo3”);
thread.start();
System.out.println(“主线程名称:”+Thread.currentThread().getName());
try {
System.out.println(futureTask.get());
} catch (InterruptedException e) {
//阻塞等待中被中断则抛出
e.printStackTrace();
} catch (ExecutionException e) {
//执行过程发送异常被抛出
e.printStackTrace();
}
}
4.通过线程池创建线程
自定义Runnable接口,实现run方法,创建线程池,调用执行方法并传入对象。
优点:安全高性能,复用线程 缺点: jdk5后才支持,需要结合Runnable进行使用
public class ThreadDemo4 implements Runnable {
@Override
public void run() {
System.out.println(“通过线程池+runnable实现多线程,名称:”+Thread.currentThread().getName());
}
}
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for(int i=0;i<10;i++){
executorService.execute(new ThreadDemo4());
}
System.out.println(“主线程名称:”+Thread.currentThread().getName());
//关闭线程池
executorService.shutdown();
}
- 一般常用的Runnable 和 第四种线程池+Runnable,简单方便扩展,和高性能 (池化的思想)
Java线程常见的基本状态
JDK的线程状态分6种,JVM里面9种。
常见的5种状态
创建(NEW):生成线程对象,但是并没有调用该对象start()。 就绪(Runnable):当调用线程对象的start()方法,线程就进入就绪状态,但是此刻线程调度还没把该线程设置为当前线程,就是没获得CPU使用权。如果线程运行后,从等待或者睡眠中回来之后,也会进入就绪状态。
运行(Running):程序将处于就绪状态的线程设置为当前线程,即获得CPU使用权,这个时候线程进入运行状态,开始运行run里面的逻辑。 阻塞(Blocked) 等待阻塞:进入该状态的线程需要等待其他线程作出一定动作(通知或中断),这种状态的话CPU不会分配过来,他们需要被唤醒,可能也会无限等待下去。比如调用wait(状态就会变成WAITING状态),也可能通过调用sleep(状态就会变成TIMED_WAITING), join或者发出IO请求,阻塞结束后线程重新进入就绪状态。
同步阻塞:线程在获取synchronized同步锁失败,即锁被其他线程占用,它就会进入同步阻塞状态。
备注:相关资料会用细分下面的状态 等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。 超时等待(TIMED_WAITING):该状态不同于WAITING,它可以在指定的时间后自行返回。
死亡(TERMINATED):一个线程run方法执行结束,该线程就死亡了,不能进入就绪状态。
多线程开发常用方法
sleep
属于线程Thread的方法; 让线程暂缓执行,等待预计时间之后再恢复; 交出CPU使用权,不会释放锁; 进入阻塞状态TIME_WAITGING,睡眠结束变为就绪Runnable;
yield
属于线程Thread的方法;
暂停当前线程的对象,去执行其他线程;
交出CPU使用权,不会释放锁,和sleep类似;
作用:让相同优先级的线程轮流执行,但是不保证一定轮流;
注意:不会让线程进入阻塞状态,直接变为就绪Runnable,只需要重新获得CPU使用权;
join
属于线程Thread的方法;
在主线程上运行调用该方法,会让主线程休眠,不会释放已经持有的对象锁;
让调用join方法的线程先执行完毕,再执行其他线程;
wait
属于Object的方法;
当前线程调用对象的wait方法,会释放锁,进入线程的等待队列;
需要依靠notify或者notifyAll唤醒,或者wait(timeout)时间自动唤醒;
notify
属于Object的方法;
唤醒在对象监视器上等待的单个线程,选择是任意的;
notifyAll
属于Object的方法;
唤醒在对象监视器上等待的全部线程;
线程的状态转换图
Java中保证线程安全的方法
-
加锁,比如synchronize/ReentrantLock
-
使用volatile声明变量,轻量级同步,不能保证原子性
-
使用线程安全类,原子类AtomicXXX,并发容器,同步CopyOnWriteArrayList/ConcurrentHashMap等
-
ThreadLocal本地私有变量/信号量Semaphore等
解析volatile关键字
volatile是轻量级的synchronized,保证了共享变量的可见性,被volatile关键字修饰的变量,如果值发生了变化,其他线程立刻可见,避免出现脏读现象。为什么会出现脏读?JAVA内存模型简称JMM,JMM规定所有的变量存在在主内存,每个线程有自己的工作内存,线程对变量的操作都在工作内存中进行,不能直接对主内存就行操作,使用volatile修饰变量,每次读取前必须从主内存属性获取最新的值,每次写入需要立刻写到主内存中。volatile关键字修修饰的变量随时看到的自己的最新值,假如线程1对变量v进行修改,那么线程2是可以马上看见的。 volatile:保证可见性,但是不能保证原子性 synchronized:保证可见性,也保证原子性
什么是指令重排
指令重排序分两类:编译器重排序和运行时重排序 JVM在编译Java代码或者CPU执行JVM字节码时,对现有的指令进行重新排序,主要目的是优化运行效率(不改变程序结果的前提)
举例: int a = 3 //第一步 1 int b = 4 //第二步 2 int c =5 //第三步 3 int h = abc //第四步 4 定义顺序 1,2,3,4 计算顺序 1,3,2,4 和 2,1,3,4 结果都是一样
什么是happens-before以及为什么需要happens-before
happens-before:A happens-before B就是A先行发生于B(这种说法不是很准确),定义为hb(A, B)。在Java内存模型中,happens-before的意思是前一个操作的结果可以被后续操作获取。JVM会对代码进行编译优化,会出现指令重排序情况,为了避免编译优化对并发编程安全性的影响,需要happens-before规则定义一些禁止编译优化的场景,保证并发编程的正确性。
happens-before八大规则
1.程序次序规则:在一个线程内一段代码的执行结果是有序的。就是还会指令重排,但是随便它怎么排,结果是按照我们代码的顺序生成的不会变。 2.管程锁定规则:就是无论是在单线程环境还是多线程环境,对于同一个锁来说,一个线程对这个锁解锁之后,另一个线程获取了这个锁都能看到前一个线程的操作结果!(管程是一种通用的同步原语,synchronized就是管程的实现) 3.volatile变量规则:就是如果一个线程先去写一个volatile变量,然后一个线程去读这个变量,那么这个写操作的结果一定对读的这个线程可见。 4.线程启动规则:在主线程A执行过程中,启动子线程B,那么线程A在启动子线程B之前对共享变量的修改结果对线程B可见。 5.线程终止规则:在主线程A执行过程中,子线程B终止,那么线程B在终止之前对共享变量的修改结果在线程A中可见。也称线程join()规则。 6.线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程代码检测到中断事件的发生,可以通过Thread.interrupted()检测到是否发生中断。 7.传递性规则:这个简单的,就是happens-before原则具有传递性,即hb(A, B) , hb(B, C),那么hb(A, C)。 8.对象终结规则:这个也简单的,就是一个对象的初始化的完成,也就是构造函数执行的结束一定 happens-before它的finalize()方法。
并发编程三要素
原子性:一个不可再被分割的颗粒,原子性指的是一个或多个操作要么全部执行成功要么全部执行失败,期间不能被中断,也不存在上下文切换,线程切换会带来原子性的问题
int num = 1; // 原子操作 num++; // 非原子操作,从主内存读取num到线程工作内存,进行 +1,再把num写到主内存, 除非用原子类,即java.util.concurrent.atomic里的原子变量类 解决办法是可以用synchronized 或 Lock(比如ReentrantLock) 来把这个多步操作“变成”原子操作
public class Test {
private int num = 0;
//使用lock,每个对象都是有锁,只有获得这个锁才可以进行对应的操作
Lock lock = new ReentrantLock();
public void add1(){
lock.lock();
try {
num++;
}finally {
lock.unlock();
}
}
//使用synchronized,和上述是一个操作,这个是保证方法被锁住而已,上述的是代码块被锁住
public synchronized void add2(){
num++;
}
}
解决核心思想:把一个方法或者代码块看做一个整体,保证是一个不可分割的整体
有序性: 程序执行的顺序按照代码的先后顺序执行,因为处理器可能会对指令进行重排序
JVM在编译java代码或者CPU执行JVM字节码时,对现有的指令进行重新排序,主要目的是优化运行效率(不改变程序结果的前提)
int a = 3 //第一步 1
int b = 4 //第二步 2
int c =5 //第三步 3
int h = abc //第四步 4
上面的例子 执行顺序1,2,3,4 和 2,1,3,4 结果都是一样,指令重排序可以提高执行效率,但是多线程上可能会影响结果 假如下面的场景,正常是顺序处理
//线程1
before();//处理初始化工作,处理完成后才可以正式运行下面的run方法
flag = true; //标记资源处理好了,如果资源没处理好,此时程序就可能出现问题
//线程2
while(flag){
run(); //核心业务代码
}
指令重排序后,导致顺序换了,程序出现问题,且难排查
//线程1
flag = true; //标记资源处理好了,如果资源没处理好,此时程序就可能出现问题
//线程2
while(flag){
run(); //核心业务代码
}
before();//处理初始化工作,处理完成后才可以正式运行下面的run方法
可见性: 一个线程A对共享变量的修改,另一个线程B能够立刻看到
// 线程 A 执行
int num = 0;
// 线程 A 执行
num++;
// 线程 B 执行
System.out.print(“num的值:” + num);
线程A执行 i++ 后再执行线程 B,线程 B可能有2个结果,可能是0和1。 因为 i++ 在线程A中执行运算,并没有立刻更新到主内存当中,而线程B就去主内存当中读取并打印,此时打印的就是0;也可能线程A执行完成更新到主内存了,线程B的值是1。所以需要保证线程的可见性,synchronized、lock和volatile能够保证线程可见性。
常见的进程间调度算法
先来先服务调度算法: 按照作业/进程到达的先后顺序进行调度 ,即:优先考虑在系统中等待时间最长的作业,排在长进程后的短进程的等待时间长,不利于短作业/进程 短作业优先调度算法: 短进程/作业(要求服务时间最短)在实际情况中占有很大比例,为了使得它们优先执行,对长作业不友好 高响应比优先调度算法: 在每次调度时,先计算各个作业的优先权:优先权=响应比=(等待时间+要求服务时间)/要求服务时间,因为等待时间与服务时间之和就是系统对该作业的响应时间,所以 优先权=响应比=响应时间/要求服务时间,选择优先权高的进行服务需要计算优先权信息,增加了系统的开销
时间片轮转调度算法: 轮流的为各个进程服务,让每个进程在一定时间间隔内都可以得到响应,由于高频率的进程切换,会增加了开销,且不区分任务的紧急程度 优先级调度算法: 根据任务的紧急程度进行调度,高优先级的先处理,低优先级的慢处理,如果高优先级任务很多且持续产生,那低优先级的就可能很慢才被处理
常见的线程间调度算法
线程调度是指系统为线程分配CPU使用权的过程,主要分两种: 协同式线程调度(分时调度模式):线程执行时间由线程本身来控制,线程把自己的工作执行完之后,要主动通知系统切换到另外一个线程上。最大好处是实现简单,且切换操作对线程自己是可知的,没啥线程同步问题。坏处是线程执行时间不可控制,如果一个线程有问题,可能一直阻塞在那里。 抢占式线程调度:每个线程将由系统来分配执行时间,线程的切换不由线程本身来决定(Java中,Thread.yield()可以让出执行时间,但无法获取执行时间)。线程执行时间系统可控,也不会由一个线程导致整个进程阻塞。 Java线程调度就是抢占式调度,优先让可运行池中优先级高的线程占用CPU,如果可运行池中的线程优先级相同,那就随机选择一个线程。所以我们如果希望某些线程多分配一些时间,给一些线程少分配一些时间,可以通过设置线程优先级来完成。
JAVA的线程的优先级,以1到10的整数指定。当多个线程可以运行时,JVM一般会运行最高优先级的线程(Thread.MIN_PRIORITY至Thread.MAX_PRIORITY)。在两线程同时处于就绪runnable状态时,优先级越高的线程越容易被系统选择执行,但是优先级并不是100%可以获得,只不过是机会更大而已。
Java多线程里面常用的锁
悲观锁:当线程去操作数据的时候,总认为别的线程会去修改数据,所以它每次拿数据的时候都会上锁,别的线程去拿数据的时候就会阻塞,比如synchronized 乐观锁:每次去拿数据的时候都认为别人不会修改,更新的时候会判断是别人是否回去更新数据,通过版本来判断,如果数据被修改了就拒绝更新,比如CAS是乐观锁,但严格来说并不是锁,是通过原子性来保证数据的同步,比如说数据库的乐观锁,通过版本控制来实现,CAS不会保证线程同步,乐观的认为在数据更新期间没有其他线程影响 小结:悲观锁适合写操作多的场景,乐观锁适合读操作多的场景,乐观锁的吞吐量会比悲观锁多。 公平锁:指多个线程按照申请锁的顺序来获取锁,简单来说,一个线程组里,能保证每个线程都能拿到锁,比如ReentrantLock(底层是同步队列FIFO:First Input First Output来实现) 非公平锁:获取锁的方式是随机获取的,保证不了每个线程都能拿到锁,也就是存在有线程饿死,一直拿不到锁,比如synchronized、ReentrantLock 小结:非公平锁性能高于公平锁,更能重复利用CPU的时间。 可重入锁:也叫递归锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁 不可重入锁:若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取锁时,就会获取不到被阻塞 小结:可重入锁能一定程度的避免死锁 ,synchronized、ReentrantLock 是重入锁。 自旋锁:一个线程在获取锁的时候,如果锁已经被其它线程获取,那么该线程将循环等待,然后不断的判断锁是否能够被成功获取,直到获取到锁才会退出循环,任何时刻最多只能有一个执行单元获得锁 小结:自旋锁不会发生线程状态的切换,一直处于用户态,减少了线程上下文切换的消耗,缺点是循环会消耗CPU。常见的自旋锁:TicketLock,CLHLock,MSCLock。
共享锁:也叫S锁/读锁,能查看但无法修改和删除的一种数据锁,加锁后其它用户可以并发读取、查询数据,但不能修改,增加,删除数据,该锁可被多个线程所持有,用于资源数据共享。 互斥锁:也叫X锁/排它锁/写锁/独占锁/独享锁/ 该锁每一次只能被一个线程所持有,加锁后任何试图再次加锁的线程会被阻塞,直到当前线程解锁。例子:如果 线程A 对 data1 加上排他锁后,则其他线程不能再对 data1 加任何类型的锁,获得互斥锁的线程即能读数据又能修改数据。 死锁:两个或两个以上的线程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法让程序进行下去。 下面三种是JVM为了提高锁的获取与释放效率而做的优化,针对Synchronized的锁升级,锁的状态是通过对象监视器在对象头中的字段来表明,是不可逆的过程。
偏向锁:一段同步代码一直被一个线程所访问,那么该线程会自动获取锁,获取锁的代价更低。
轻量级锁:当锁是偏向锁的时候,被其他线程访问,偏向锁就会升级为轻量级锁,其他线程会通过自旋的形式尝试获取锁,但不会阻塞,且性能会高点。
重量级锁:当锁为轻量级锁的时候,其他线程虽然是自旋,但自旋不会一直循环下去,当自旋一定次数的时候且还没有获取到锁,就会进入阻塞,该锁升级为重量级锁,重量级锁会让其他申请的线程进入阻塞,性能也会降低。 分段锁、行锁、表锁
编写多线程死锁的例子
死锁:线程在获得了锁A并且没有释放的情况下去申请锁B,这时另一个线程已经获得了锁B,在释放锁B之前又要先获得锁A,因此闭环发生,陷入死锁循环。
public class DeadLockDemo {
private static String locka = “locka”;
private static String lockb = “lockb”;
public void methodA(){
synchronized (locka){
System.out.println("我是A方法中获得了锁A "+Thread.currentThread().getName() );
//让出CPU执行权,不释放锁
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(lockb){
System.out.println("我是A方法中获得了锁B "+Thread.currentThread().getName() );
}
}
}
public void methodB(){
synchronized (lockb){
System.out.println("我是B方法中获得了锁B "+Thread.currentThread().getName() );
//让出CPU执行权,不释放锁
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(locka){
System.out.println("我是B方法中获得了锁A "+Thread.currentThread().getName() );
}
}
}
public static void main(String [] args){
System.out.println(“主线程运行开始运行:”+Thread.currentThread().getName());
DeadLockDemo deadLockDemo = new DeadLockDemo();
new Thread(()->{
deadLockDemo.methodA();
}).start();
new Thread(()->{
deadLockDemo.methodB();
}).start();
System.out.println(“主线程运行结束:”+Thread.currentThread().getName());
}
}
对于上面的例子如何解决死锁,常见的解决办法有两种:
-
调整申请锁的范围
-
调整申请锁的顺序
public class FixDeadLockDemo {
private static String locka = “locka”;
private static String lockb = “lockb”;
public void methodA(){
synchronized (locka){
System.out.println("我是A方法中获得了锁A "+Thread.currentThread().getName() );
//让出CPU执行权,不释放锁
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized(lockb){
System.out.println("我是A方法中获得了锁B "+Thread.currentThread().getName() );
}
}
public void methodB(){
synchronized (lockb){
System.out.println("我是B方法中获得了锁B "+Thread.currentThread().getName() );
//让出CPU执行权,不释放锁
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized(locka){
System.out.println("我是B方法中获得了锁A "+Thread.currentThread().getName() );
}
}
public static void main(String [] args){
System.out.println(“主线程运行开始运行:”+Thread.currentThread().getName());
FixDeadLockDemo deadLockDemo = new FixDeadLockDemo();
for(int i=0; i<10;i++){
new Thread(()->{
deadLockDemo.methodA();
}).start();
new Thread(()->{
deadLockDemo.methodB();
}).start();
}
System.out.println(“主线程运行结束:”+Thread.currentThread().getName());
}
}
死锁的4个必要条件:
-
互斥条件:进程对所分配到的资源不允许其他进程进行访问,若其他进程访问该资源,只能等待,直至占有该资源的进程使用完成后释放该资源
-
请求和保持条件:进程获得一定的资源之后,又对其他资源发出请求,但是该资源可能被其他进程占有,此事请求阻塞,但又对自己获得的资源保持不放
-
不可剥夺条件:是指进程已获得的资源,在未完成使用之前,不可被剥夺,只能在使用完后自己释放
-
环路等待条件:是指进程发生死锁后,若干进程之间形成一种头尾相接的循环等待资源关系
这四个条件是死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之 一不满足,就不会发生死锁。
设计一个简单的不可重入锁例子
不可重入锁:若当前线程执行某个方法已经获取了该锁,那么在其他方法中尝试再次获取锁时,就会获取不到被阻塞。
private void methodA(){
//获取锁 TODO
methodB();
}
private void methodB(){
//获取锁 TODO
//其他操作
}
/**
-
不可重入锁 简单例子
-
不可重入锁:若当前线程执行某个方法已经获取了该锁,那么在其他方法中尝试再次获取锁时,就会获取不到被阻塞
*/
public class UnreentrantLock {
private boolean isLocked = false;
public synchronized void lock() throws InterruptedException {
System.out.println("进入lock加锁 "+Thread.currentThread().getName());
//判断是否已经被锁,如果被锁则当前请求的线程进行等待
while (isLocked){
System.out.println("进入wait等待 "+Thread.currentThread().getName());
wait();
}
//进行加锁
isLocked = true;
}
public synchronized void unlock(){
System.out.println("进入unlock解锁 "+Thread.currentThread().getName());
isLocked = false;
//唤醒对象锁池里面的一个线程
notify();
}
}
public class Main {
private UnreentrantLock unreentrantLock = new UnreentrantLock();
//加锁建议在try里面,解锁建议在finally
public void methodA(){
try {
unreentrantLock.lock();
System.out.println(“methodA方法被调用”);
methodB();
}catch (InterruptedException e){
e.fillInStackTrace();
} finally {
unreentrantLock.unlock();
}
}
public void methodB(){
try {
unreentrantLock.lock();
System.out.println(“methodB方法被调用”);
}catch (InterruptedException e){
e.fillInStackTrace();
} finally {
unreentrantLock.unlock();
}
}
public static void main(String [] args){
//演示的是同个线程
new Main().methodA();
}
}
//同一个线程,重复获取锁失败,形成死锁,这个就是不可重入锁
设计一个简单的可重入锁例子
可重入锁:也叫递归锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁
/**
-
可重入锁 简单例子
-
可重入锁:也叫递归锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁
*/
public class ReentrantLock {
private boolean isLocked = false;
//用于记录是不是重入的线程
private Thread lockedOwner = null;
//累计加锁次数,加锁一次累加1,解锁一次减少1
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
Spring全套教学资料
Spring是Java程序员的《葵花宝典》,其中提供的各种大招,能简化我们的开发,大大提升开发效率!目前99%的公司使用了Spring,大家可以去各大招聘网站看一下,Spring算是必备技能,所以一定要掌握。
目录:
部分内容:
Spring源码
- 第一部分 Spring 概述
- 第二部分 核心思想
- 第三部分 手写实现 IoC 和 AOP(自定义Spring框架)
- 第四部分 Spring IOC 高级应用
基础特性
高级特性 - 第五部分 Spring IOC源码深度剖析
设计优雅
设计模式
注意:原则、方法和技巧 - 第六部分 Spring AOP 应用
声明事务控制 - 第七部分 Spring AOP源码深度剖析
必要的笔记、必要的图、通俗易懂的语言化解知识难点
脚手框架:SpringBoot技术
它的目标是简化Spring应用和服务的创建、开发与部署,简化了配置文件,使用嵌入式web服务器,含有诸多开箱即用的微服务功能,可以和spring cloud联合部署。
Spring Boot的核心思想是约定大于配置,应用只需要很少的配置即可,简化了应用开发模式。
- SpringBoot入门
- 配置文件
- 日志
- Web开发
- Docker
- SpringBoot与数据访问
- 启动配置原理
- 自定义starter
微服务架构:Spring Cloud Alibaba
同 Spring Cloud 一样,Spring Cloud Alibaba 也是一套微服务解决方案,包含开发分布式应用微服务的必需组件,方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。
- 微服务架构介绍
- Spring Cloud Alibaba介绍
- 微服务环境搭建
- 服务治理
- 服务容错
- 服务网关
- 链路追踪
- ZipKin集成及数据持久化
- 消息驱动
- 短信服务
- Nacos Confifig—服务配置
- Seata—分布式事务
- Dubbo—rpc通信
Spring MVC
目录:
部分内容:
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
的创建、开发与部署,简化了配置文件,使用嵌入式web服务器,含有诸多开箱即用的微服务功能,可以和spring cloud联合部署。
Spring Boot的核心思想是约定大于配置,应用只需要很少的配置即可,简化了应用开发模式。
- SpringBoot入门
- 配置文件
- 日志
- Web开发
- Docker
- SpringBoot与数据访问
- 启动配置原理
- 自定义starter
[外链图片转存中…(img-nNLPtBcT-1713753895197)]
[外链图片转存中…(img-F0LyY30p-1713753895197)]
微服务架构:Spring Cloud Alibaba
同 Spring Cloud 一样,Spring Cloud Alibaba 也是一套微服务解决方案,包含开发分布式应用微服务的必需组件,方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。
- 微服务架构介绍
- Spring Cloud Alibaba介绍
- 微服务环境搭建
- 服务治理
- 服务容错
- 服务网关
- 链路追踪
- ZipKin集成及数据持久化
- 消息驱动
- 短信服务
- Nacos Confifig—服务配置
- Seata—分布式事务
- Dubbo—rpc通信
[外链图片转存中…(img-GCheoNKz-1713753895197)]
[外链图片转存中…(img-zhPZIVdR-1713753895198)]
Spring MVC
目录:
[外链图片转存中…(img-Sfia1LvE-1713753895198)]
[外链图片转存中…(img-6u4BpmIY-1713753895198)]
[外链图片转存中…(img-EZ4GxcQb-1713753895198)]
部分内容:
[外链图片转存中…(img-qjNt0A8b-1713753895198)]
[外链图片转存中…(img-PFMfmpT4-1713753895198)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!