java多线程并发系列--基础知识点（笔试、面试必备）

时间  2020-01-10
标签 java 多线程 并发 系列 基础 知识 笔试 面试 必备 栏目 Java 繁體版
原文   原文链接
关注我，能够获取最新知识、经典面试题以及技术分享

  多线程和并发是求职大小厂面试中必问的知识点，其涉及到点不少，难度很大。有些人面对这些问题有点迷茫，为了解决这状况，总结了一下java多线程并发的基础知识点。并且要想深刻研究java多线程并发也必须先掌握基础知识，可为后续各个模块深刻研究作好作好准备。如今废话很少说，各位看官请查看基础知识点，后续还有源码解析（synchronize底层原理，线程池原理，Lock，AQS，同步、并发容器等源码解析）。java

1 基本概念

 程序： 是计算机指令的集合，它以文件的形式存储在磁盘上,即程序是静态的代码面试

 进程：数据库

  • 是一个程序在其自身的地址空间中的一次执行活动,是系统运行程序的基本单位
  • 进程是资源申请、调度和独立运行的单位

 线程：设计模式

  • 是进程中的一个单一的连续控制流程。一个进程能够拥有多个线程。
  • 线程又称为轻量级进程，它和进程同样拥有独立的执行控制，由操做系统负责调度，区

别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这
使得线程间的通讯远较进程简单。数组

 三者之间的关系:缓存

  • 线程是进程划分红的更小的运行单位。线程和进程最大的不一样在于基本上各进程是独立的，而各线程则不必定，由于同一进程中的线程极有可能会相互影响。
  • 从另外一角度来讲，进程属于操做系统的范畴，主要是同一段时间内，能够同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

内存机制可查看文章《推荐收藏系列：一文理解JVM虚拟机（内存、垃圾回收、性能优化）解决面试中遇到问题》安全

2 线程组成

组成部分：虚拟CPU、执行的代码以及处理的数据。
性能优化

3 线程与进程区别

 进程： 指系统中正在运行中的应用程序，它拥有本身独立的内存空间；多线程

 线程： 是指进程中一个执行流程，一个进程中容许同时启动多个线程，他们分别执行不一样的任务,多个线程共享内存，从而极大地提升了程序的运行效率;并发

 主要区别：

  • 每一个进程都须要操做系统为其分配独立的内存地址空间
  • 而同一进程中的全部线程在同一块地址空间中，这些线程能够共享数

据，所以线程间的通讯比较简单，消耗的系统开销也相对较小

4 为何要使用多线程

 使用多线程好处：

  • 能够同时并发执行多个任务
  • 程序的某个功能部分正在等待某些资源的时候，此时又不肯意由于等待而形成程序暂停，那么就能够建立另外的线程进行其它的工做；
  • 多线程能够最大限度地减低CPU的闲置时间，从而提升CPU的利用率；

5 主线程

Java程序启动时，一个线程马上运行，它执行main方法，这个线程称为程序的主线程，任何Java程序都至少有一个线程，即主线程。

 主线程的特殊之处在于：

  • 它是产生其它线程子线程的线程；
  • 一般它必须最后结束，由于它要执行其它子线程的关闭工做。

6 线程优先级

单核计算机只有一个CPU，各个线程轮流得到CPU的使用权，才能执行任务：

  • 优先级较高的线程有更多得到CPU的机会，反之亦然；
  • 优先级用整数表示，取值范围是1~10，通常状况下，线程的默认
  • 优先级都是5，可是也能够经过setPriority和getPriority方法来设置或返回优先级；

Thread类有以下3个静态常量来表示优先级：

  • MAX_PRIORITY：取值为10，表示最高优先级
  • MIN_PRIORITY：取值为1，表示最低优先级
  • NORM_PRIORITY：取值为5，表示默认的优先级

7 线程的生命周期

 线程状态(State枚举值表明线程状态)：

  • 新建状态（ NEW）： 线程刚建立, 还没有启动。Thread thread = new Thread()。
  • 可运行状态（RUNNABLE）： 线程对象建立后，其余线程(好比 main 线程）调用了该对象的 start 方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权。
  • 运行(running)： 线程得到 CPU 资源正在执行任务（run() 方法），此时除非此线程自动放弃 CPU 资源或者有优先级更高的线程进入，线程将一直运行到结束
  • 阻塞状态（Blocked）： 线程正在运行的时候，被暂停，一般是为了等待某个时间的发生(好比说某项资源就绪)以后再继续运行。sleep,suspend，wait等方法均可以致使线程阻塞
  • 等待（WAITING）： 进入该状态的线程须要等待其余线程作出一些特定动做（通知或中断）。
  • 超时等待(TIMED_WAITING)： 该状态不一样于WAITING，它能够在指定的时间后自行返回。
  • 终止(TERMINATED)： 表示该线程已经执行完毕，若是一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，没法再使用start方法令其进入就绪。

 线程在Running的过程当中可能会遇到阻塞(Blocked)状况：

  • 调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。
  • 调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable）
  • 对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。

8 线程建立方式

 线程建立方式：

  • 实现Runnable接口，重载run()，无返回值
  • 继承Thread类，复写run()
  • 实现Callable接口，经过FutureTask/Future来建立有返回值的Thread线程，经过Executor执行
  • 使用Executors建立ExecutorService，入参Callable或Future

1.实现Runnable接口，重载run()，无返回值，Runnable接口的存在主要是为了解决Java中不容许多继承的问题。

public class ThreadRunnable implements Runnable {
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName() + ":" + i);
    }
  }
}
  
public class ThreadMain {
  public static void main(String[] args) throws Exception {
    ThreadRunnable threadRunnable1 = new ThreadRunnable();
    ThreadRunnable threadRunnable2 = new ThreadRunnable();
    ThreadRunnable threadRunnable3 = new ThreadRunnable();
    Thread thread1 = new Thread(threadRunnable1);
    Thread thread2 = new Thread(threadRunnable2);
    Thread thread3 = new Thread(threadRunnable3);    
    thread1.start();
    thread2.start();
    thread3.start();
  }
}

2.继承Thread类，重写run()，经过调用Thread的start()会调用建立线程的run()，不一样线程的run方法里面的代码交替执行。但因为Java不支持多继承.所以继承Thread类就表明这个子类不能继承其余类.

public class ThreadCustom extends Thread {
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread() + ":" + i);
    }
  }
}
  
  
public class ThreadTest {
  public static void main(String[] args)
  {
    ThreadCustom thread = new ThreadCustom();
    thread.start();
  }
}

3.实现Callable接口，经过FutureTask/Future来建立有返回值的Thread线程，经过Executor执行，该方式有返回值，能够得到异步。

public class ThreadCallableCustom {
  public static void main(String[] args) throws Exception {
    FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
      public Integer call() throws Exception {
        for (int i = 0; i < 10; i++) {
          System.out.println(Thread.currentThread().getName() + ":" + i);
        }
        return 1;
      }
    });
    Executor executor = Executors.newFixedThreadPool(1);
    ((ExecutorService) executor).submit(futureTask);
  
    //得到线程执行状态
    System.out.println(Thread.currentThread().getName() + ":" + futureTask.get());
  }
}

4.使用Executors建立ExecutorService，入参Callable或Future，适用于线程池和并发

public class ThreadExecutors {
  private final String threadName;
  
  public ThreadExecutors(String threadName) {
    this.threadName = threadName;
  }
  
  private ThreadFactory createThread() {
    ThreadFactory tf = new ThreadFactory() {
      public Thread newThread(Runnable r) {
        Thread thread = new Thread();
        thread.setName(threadName);
        thread.setDaemon(true);
        try {
          sleep(1000);
        }
        catch (InterruptedException e) {
          e.printStackTrace();
        }
        return thread;
      }
    };
    return tf;
  }
  
  public Object runCallable(Callable callable) {
    return Executors.newSingleThreadExecutor(createThread()).submit(callable);
  }
  
  public Object runFunture(Runnable runnable) {
    return Executors.newSingleThreadExecutor(createThread()).submit(runnable);
  }
}

public class ThreadTest {
  public static void main(String[] args) throws Exception {
    ThreadExecutors threadExecutors = new ThreadExecutors("callableThread");
    threadExecutors.runCallable(new Callable() {
      public String call() throws Exception {
        return "success";
      }
    });
  
    threadExecutors.runFunture(new Runnable() {
      public void run() {
        System.out.println("execute runnable thread.");
      }
    });
  }
}

9 Runnable接口和Callable接口区别

1）两个接口须要实现的方法名不同，Runnable须要实现的方法为run()，Callable须要实现的方法为call()。
2）实现的方法返回值不同，Runnable任务执行后无返回值，Callable任务执行后能够获得异步计算的结果。
3）抛出异常不同，Runnable不能够抛出异常，Callable能够抛出异常。

10 线程安全

线程安全定义

当多个线程访问某个一类(对象或方法)时，这个类始终都能表现出正确的行为，那么这个类(对象或方法)就是线程安全的(即在多线程环境中被调用时，可以正确地处理多个线程之间的共享变量，使程序功能正确完成)。

线程安全示例

饿汉式单例模式-线程安全

public class EagerSingleton(){
 
    private static final EagerSingleton instance = new EagerSingleton();
 
    private EagerSingleton(){};
    
    public static EagerSingleton getInstance(){
       return instance;
    }
}

如何解决线程安全问题？

能够经过加锁的方式：

  • 同步(synchronized)代码块：只须要将操做共享数据的代码放在synchronized
  • 同步(synchronized)方法：将操做共享数据的代码抽取出来放到一个synchronized方法里面就能够了
  • Lock锁：加同步锁 lock() 以及释放同步锁unlock()

11 什么是死锁、活锁？

死锁，是指两个或两个以上的进程（或线程）在执行过程当中，因争夺资源而形成的一种互相等待的现象，若无外力做用，它们都将没法推动下去。

活锁，任务或者执行者没有被阻塞，因为某些条件没有知足，致使一直重复尝试，失败，尝试，失败。

 产生死锁的必要条件：

  • 互斥条件：所谓互斥就是进程在某一时间内独占资源。
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已得到的资源保持不放。
  • 不剥夺条件：进程已得到资源，在末使用完以前，不能强行剥夺。
  • 循环等待条件：若干进程之间造成一种头尾相接的循环等待资源关系。

 死锁的解决方法：

  • 撤消陷于死锁的所有进程。
  • 逐个撤消陷于死锁的进程，直到死锁不存在。
  • 从陷于死锁的进程中逐个强迫放弃所占用的资源，直至死锁消失。

从另一些进程那里强行剥夺足够数量的资源分配给死锁进程，以解除死锁状态。

12 什么是悲观锁、乐观锁？

1）悲观锁

悲观锁，老是假设最坏的状况，每次去拿数据的时候都认为别人会修改，因此每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。

  • 传统的关系型数据库里边就用到了不少这种锁机制，好比行锁，表锁等，读锁，写锁等，都是在作操做以前先上锁。
  • Java 里面的同步原语 synchronized 关键字的实现也是悲观锁。

2）乐观锁

乐观锁，顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，因此不会上锁，可是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可使用版本号等机制。乐观锁适用于多读的应用类型，这样能够提升吞吐量。

13 多个线程间锁的并发控制

多个线程间锁的并发控制,对象锁多个线程、每一个线程持有该方法所属对象的锁以及类锁。synchronized, wait, notify 是任何对象都具备的同步工具

对象锁的同步和异步

  • 同步：synchronized，同步的概念就是共享，只须要针对共享的资源，才须要考虑同步。
  • 异步：asynchronized，异步的概念就是独立，相互之间不受到任何制约。

同步的目的就是为线程安全，其实对于线程安全来讲，须要知足两个特性：原子性(同步)、可见性。

14 Volatile关键字

Volatile做用，实现变量在多个线程间可见，保证内存可见性和禁止指令重排

多线程的内存模型：main memory（主存）、working

memory（线程栈），在处理数据时，线程会把值从主存load到本地栈，完成操做后再save回去(volatile关键词的做用：每次针对该变量的操做都激发一次load and save)。

15 ThreadLocal

  线程局部变量，以空间换时间的手段，为每一个线程提供变量的独立副本，以无锁的状况下保障线程安全。主要解决的就是让每一个线程执行完成以后再结束，这个时候就要用到join()方法。

适用场景：

  • 在并发不是很高的时候，加锁的性能会更好
  • 在高并发量场景下，使用ThreadLocal能够在必定程度上减小锁竞争。

16 多线程同步和互斥实现方法

  1). 线程同步，是指线程之间所具备的一种制约关系，一个线程的执行依赖另外一个线程的消息，当它没有获得另外一个线程的消息时应等待，直到消息到达时才被唤醒。

 线程间的同步方法，大致可分为两类：用户模式和内核模式。顾名思义：

内核模式，就是指利用系统内核对象的单一性来进行同步，使用时须要切换内核态与用户态。内核模式下的方法有：

  • 事件
  • 信号量
  • 互斥量

用户模式，就是不须要切换到内核态，只在用户态完成操做。用户模式下的方法有：

  • 原子操做（例如一个单一的全局变量）
  • 临界区

  2). 线程互斥，是指对于共享的进程系统资源，在各单个线程访问时的排它性。

当有若干个线程都要使用某一共享资源时，任什么时候刻最多只容许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。
线程互斥能够当作是一种特殊的线程同步。

17 线程之间通讯

线程是操做系统中独立的个体，但这些个体之间若是不通过特殊的协做就不能成为一个总体，线程间的通讯就成为总体的必用方式之一。

线程间通讯的几种方式？

线程之间的通讯方式:

  • 共享内存
  • 消息传递

共享内存：在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间经过写-读内存中的公共状态来隐式进行通讯。典型的共享内存通讯方式，就是经过共享对象进行通讯。


消息传递：在消息传递的并发模型里，线程之间没有公共状态，线程之间必须经过明确的发送消息来显式进行通讯。在 Java 中典型的消息传递方式，就是 wait() 和 notify() ，或者 BlockingQueue 。

18 什么是 Java Lock 接口？

java.util.concurrent.locks.Lock 接口，比 synchronized 提供更具拓展行的锁操做。它容许更灵活的结构，能够具备彻底不一样的性质，而且能够支持多个相关类的条件对象。它的优点有：

  • 可使锁更公平。
  • 可使线程在等待锁的时候响应中断。
  • 可让线程尝试获取锁，并在没法获取锁的时候当即返回或者等待一段时间。
  • 能够在不一样的范围，以不一样的顺序获取和释放锁。

19 Java AQS

AQS ，AbstractQueuedSynchronizer ，即队列同步器。它是构建锁或者其余同步组件的基础框架（如 ReentrantLock、ReentrantReadWriteLock、Semaphore 等），J.U.C 并发包的做者（Doug Lea）指望它可以成为实现大部分同步需求的基础。它是 J.U.C 并发包中的核心基础组件。

 优点：

AQS 解决了在实现同步器时涉及当的大量细节问题，例如获取同步状态、FIFO 同步队列。基于 AQS 来构建同步器能够带来不少好处。它不只可以极大地减小实现工做，并且也没必要处理在多个位置上发生的竞争问题。

在基于 AQS 构建的同步器中，只能在一个时刻发生阻塞，从而下降上下文切换的开销，提升了吞吐量。同时在设计 AQS 时充分考虑了可伸缩性，所以 J.U.C 中，全部基于 AQS 构建的同步器都可以得到这个优点。

20 同步类容器

何为同步容器？能够简单地理解为经过synchronized来实现同步的容器，若是有多个线程调用同步容器的方法，它们将会串行执行。

 特色：

  • 是线程安全的
  • 某些场景下可能须要加锁来保护复合操做

 常见同步类容器：

  • 如Vector、HashTable
  • 使用JDK的Collections.synchronized等工厂方法去建立实现的。
  • 底层是用传统的synchronized关键字对方法进行同步。
  • 没法知足高并发场景下的性能需求

21 并发类容器

jdk5.0之后提供了多种并发类容器来替代同步类容器从而改善性能。

同步类容器局限性：

  • 都是串行化的。
  • 虽实现了线程安全，却下降了并发性
  • 在多线程环境时，严重下降了应用程序的吞吐量。

经常使用的并发类容器:

  • ConcurrentHashMap
  • Copy-On-Write容器

 ConcurrentHashMap原理

  • 内部使用段(Segment)来表示这些不一样的部分
  • 每一个段至关于一个小的HashTable，它们有本身的锁。
  • 把一个总体分红了16个段(Segment)。也就是最高支持16个线程的并发修改操做。
  • 这也是在多线程场景时经过减少锁的粒度从而下降锁竞争的一种方案。

 Copy-On-Write容器

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。

  • 读写分离，读和写分开
  • 最终一致性
  • 使用另外开辟空间的思路，来解决并发冲突

 JDK里的COW容器有两种：

  • CopyOnWriteArrayList:适用于读操做远远多于写操做的场景,例如，缓存.
  • CopyOnWriteArraySet:线程安全的无序的集合，能够将它理解成线程安全的HashSet,适用于Set 大小一般保持很小，只读操做远多于可变操做，须要在遍历期间防止线程间的冲突

22 并发Queue

 并发Queue:

  • ConcurrentLinkedQueue,高性能队列，当许多线程共享访问一个公共集合时，ConcurrentLinkedQueue 是一个恰当的选择。
  • BlockingQueue,阻塞队列,是一个支持两个附加操做的队列,经常使用于生产者和消费者的场景。

 ConcurrentLinkedQueue

  • 适用于高并发场景
  • 使用无锁的方式，实现了高并发状态下的高性能
  • 其性能好于BlockingQueue
  • 遵循先进先出的原则

经常使用方法：

  • Add()和offer()都是加入元素的方法
  • Poll()和peek()都是取头元素节点，区别在于前者会删除元素，后者不会。

 BlockingQueue接口实现：

  • ArrayBlockingQueue：基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长的数组，以便缓存队列中的数据对象，其内部没实现读写分离，也就意味着生产和消费者不能彻底并行，适用不少场景。
  • LinkedBlockingQueue：基于链表的阻塞队列，同ArrayBlockingQueue相似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），LinkedBlockingQueue之因此可以高效地处理并发数据，是由于其内部实现采用分离锁（读写分离两个锁），从而实现生产者和消费者操做彻底并行运行。
  • PriorityBlockingQueue：基于优先级别的阻塞队列（优先级的判断经过构造函数传入的Compator对象来决定，也就是说传入队列的对象必须实现Comparable接口），在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁
  • DelayQueue：带有延迟时间的Queue，其中的元素只有当其指定的延迟时间到了，才可以从队列中获取到该元素。DelayQueue中的元素必须先实现Delayed接口，DelayQueue是一个没有大小限制的队列，应用场景不少，好比对缓存超时的数据进行移除、任务超时处理、空闲链接的关闭等等。
  • SynchronousQueue：一种没有缓冲的队列，生产者产生的数据直接会被消费者获取而且马上消费

23 多线程的设计模式

  • 基于并行设计模式演变而来
  • 属于设计优化的一部分
  • 是对一些经常使用的多线程结构的总结和抽象
  • 常见的多线程设计模式有哪些？

24 Concurrent.util经常使用类

CountDownLatch： 用于监听某些初始化操做，等初始化执行完毕后，通知主线程继续工做。

CycilcBarrier： 全部线程都准备好后，才一块儿出发，只要有一我的没有准备好，你们都等待。

Concurrent.util经常使用类
定义：实现异步回调，jdk针对该场景提供了一个实现的封装，简化了调用
适合场景：处理耗时的业务逻辑时，可有效的减小系统的响应时间，提升系统的吞吐量。

Concurrent.util经常使用类
Semaphore：信号量，适合高并发访问， 用于进行访问流量的控制

ReentrantLock(重入锁)
重入锁，在须要进行同步的代码部分加上锁定，但不要忘记最后必定要释放锁定，否则会形成锁永远没法释放，其余线程永远也进不来的结果。

 锁与等待/通知

  • 多线程间进行协做工做则须要Object的wait()和notify()、notifyAll()方法进行配合工做
  • 在使用锁的时候，可使用一个新的等待/通知的类，它就是Condition
  • 这个Condition是针对具体某一把锁的

 多Condition

  • 可经过一个Lock对象产生多个Condition进行多线程间的交互
  • 使得部分须要唤醒的线程唤醒，其余线程则继续等待通知。

 ReentrantReadWriteLock(读写锁)

  • 其核心就是实现读写分离的锁。尤为适应在在高并发访问下读多写少的状况下，性能要远高于重入锁。
  • 将读写锁分离为读锁和写锁
  • 在读锁下，多个线程能够并发进行访问
  • 在写锁下，只能一个一个的顺序访问
  • 锁优化

25 线程池

 使用 Executor 框架的缘由：

  • 每次执行任务建立线程 new Thread() 比较消耗性能，建立一个线程是比较耗时、耗资源的。
  • 调用 new Thread() 建立的线程缺少管理，被称为野线程，并且能够无限制的建立，线程之间的相互竞争会致使过多占用系统资源而致使系统瘫痪，还有线程之间的频繁交替也会消耗不少系统资源。
  • 接使用 new Thread() 启动的线程不利于扩展，好比定时执行、按期执行、定时按期执行、线程中断等都不便实现

 线程池的建立方式：

普通任务线程池

  • newFixedThreadPool(int nThreads) 方法，建立一个固定长度的线程池。

    • 每当提交一个任务就建立一个线程，直到达到线程池的最大数量，这时线程规模将再也不变化。
    • 当线程发生未预期的错误而结束时，线程池会补充一个新的线程。

  • newCachedThreadPool() 方法，建立一个可缓存的线程池。

    • 若是线程池的规模超过了处理需求，将自动回收空闲线程。
    • 当需求增长时，则能够自动添加新线程。线程池的规模不存在任何限制。

  • newSingleThreadExecutor() 方法，建立一个单线程的线程池。

    • 它建立单个工做线程来执行任务，若是这个线程异常结束，会建立一个新的来替代它。
    • 它的特色是，能确保依照任务在队列中的顺序来串行执行。

定时任务线程池

  • newScheduledThreadPool(int corePoolSize) 方法，建立了一个固定长度的线程池，并且以延迟或定时的方式来执行任务，相似 Timer 。
  • newSingleThreadExecutor() 方法，建立了一个固定长度为 1 的线程池，并且以延迟或定时的方式来执行任务，相似 Timer 。

 线程池的关闭方式

ThreadPoolExecutor 提供了两个方法，用于线程池的关闭，分别是：

  • shutdown() 方法，不会当即终止线程池，而是要等全部任务缓存队列中的任务都执行完后才终止，但不再会接受新的任务。
  • shutdownNow() 方法，当即终止线程池，并尝试打断正在执行的任务，而且清空任务缓存队列，返回还没有执行的任务

26 总结

  因为java多线程并发涉及到的知识点太多了，这边不可能一一列全，不过我会在后续的更新中一一去补充完善，并且会涉及原理以及源码层次的解析。谢谢观看，有错误欢迎指出更改！！

最后麻烦各位看官点个赞，谢谢支持！！！
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程