java面试题目解答

最新推荐文章于 2024-06-20 20:20:21 发布

辰小影

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量156

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_41047000/article/details/107516476

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

由于自己知识量不足,特意到处总结资料统计

Switch数据类型支持哪些

基本数据类型：byte, short, char, int
包装数据类型：Byte, Short, Character, Integer
枚举类型：Enum
字符串类型：String（Jdk 7+ 开始支持）

Java有哪些锁？

公平锁/非公平锁
可重入锁
独享锁/共享锁
互斥锁/读写锁
乐观锁/悲观锁
分段锁
偏向锁/轻量级锁/重量级锁
自旋锁

Java内存模型

关于主内存与工作内存之间的具体协议，即一个变量如何从主内存拷贝到工作内存，如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了一下八种操作来完成：

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。

unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用

load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。

use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。

assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。

store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。

write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

Java内存结构

程序计数器
Java虚拟机栈
本地方法栈
堆
方法区。

线程池使用场景及其核心参数说明

newCachedThreadPool：

底层：返回ThreadPoolExecutor实例，corePoolSize为0；maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为60L；unit为TimeUnit.SECONDS；workQueue为SynchronousQueue(同步队列)
通俗：当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。
适用：执行很多短期异步的小程序或者负载较轻的服务器

newFixedThreadPool：

底层：返回ThreadPoolExecutor实例，接收参数为所设定线程数量nThread，corePoolSize为nThread，maximumPoolSize为nThread；keepAliveTime为0L(不限时)；unit为：TimeUnit.MILLISECONDS；WorkQueue为：new LinkedBlockingQueue<Runnable>() 无解阻塞队列
通俗：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：执行长期的任务，性能好很多

newSingleThreadExecutor:

底层：FinalizableDelegatedExecutorService包装的ThreadPoolExecutor实例，corePoolSize为1；maximumPoolSize为1；keepAliveTime为0L；unit为：TimeUnit.MILLISECONDS；workQueue为：new LinkedBlockingQueue<Runnable>() 无解阻塞队列
通俗：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)
适用：一个任务一个任务执行的场景

NewScheduledThreadPool:

底层：创建ScheduledThreadPoolExecutor实例，corePoolSize为传递来的参数，maximumPoolSize为Integer.MAX_VALUE；keepAliveTime为0；unit为：TimeUnit.NANOSECONDS；workQueue为：new DelayedWorkQueue() 一个按超时时间升序排序的队列
通俗：创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构
适用：周期性执行任务的场景

参数说明:

corePoolSize：线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最大数量
keepAliveTime：线程池维护线程所允许的空闲时间
unit：线程池维护线程所允许的空闲时间的单位
workQueue：线程池所使用的缓冲队列
handler：线程池对拒绝任务的处理策略

Threadlocal原理和使用场景

ThreadLocal 适用于如下两种场景

每个线程需要有自己单独的实例
实例需要在多个方法中共享，但不希望被多线程共享

原理:

首先 ThreadLocal 是一个泛型类，保证可以接受任何类型的对象。

因为一个线程内可以存在多个 ThreadLocal 对象，所以其实是 ThreadLocal 内部维护了一个 Map ，这个 Map 不是直接使用的 HashMap ，而是 ThreadLocal 实现的一个叫做 ThreadLocalMap 的静态内部类。而我们使用的 get()、set() 方法其实都是调用了这个ThreadLocalMap类对应的 get()、set() 方法。例如下面的 set 方法：

 public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
 }

get方法

public T get() {   
        Thread t = Thread.currentThread();   
        ThreadLocalMap map = getMap(t);   
        if (map != null)   
            return (T)map.get(this);   
  
        // Maps are constructed lazily.  if the map for this thread   
        // doesn't exist, create it, with this ThreadLocal and its   
        // initial value as its only entry.   
        T value = initialValue();   
        createMap(t, value);   
        return value;   
    }

createMap方法：

 void createMap(Thread t, T firstValue) {   
        t.threadLocals = new ThreadLocalMap(this, firstValue);   
    }

ThreadLocalMap是个静态的内部类：

 static class ThreadLocalMap {   
    ........   
    }

最终的变量是放在了当前线程的 ThreadLocalMap 中，并不是存在 ThreadLocal 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。

实现多线程通讯

一循环实现

/资源类
class MyList {

	//临界资源
	private volatile List<String> list = new ArrayList<String>();

	public void add() {
		list.add("abc");
	}

	public int size() {
		return list.size();
	}
}

// 线程A
class ThreadA extends Thread {

	private MyList list;

	public ThreadA(MyList list,String name) {
		super(name);
		this.list = list;
	}

	@Override
	public void run() {
		try {
			for (int i = 0; i < 3; i++) {
				list.add();
				System.out.println("添加了" + (i + 1) + "个元素");
				Thread.sleep(1000);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

//线程B
class ThreadB extends Thread {

	private MyList list;

	public ThreadB(MyList list,String name) {
		super(name);
		this.list = list;
	}

	@Override
	public void run() {
		try {
			while (true) {          // while 语句轮询
				if (list.size() == 2) {
					System.out.println("==2了，线程b要退出了！");
					throw new InterruptedException();
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

//测试
public class Test {
	public static void main(String[] args) {
		
		MyList service = new MyList();

		ThreadA a = new ThreadA(service,"A");
		ThreadB b = new ThreadB(service,"B");
		
		a.start();
		b.start();
	}
}/* Output(输出结果不唯一): 
        添加了1个元素
        添加了2个元素
        ==2了，线程b要退出了！
        java.lang.InterruptedException
	        at test.ThreadB.run(Test.java:57)
        添加了3个元素
 *///:~

二. wait/notify 机制

public class Test {
	public static Object object = new Object();

	public static void main(String[] args) throws InterruptedException {
		Thread1 thread1 = new Thread1();
		Thread2 thread2 = new Thread2();

		thread1.start();

		Thread.sleep(2000);

		thread2.start();
	}

	static class Thread1 extends Thread {
		@Override
		public void run() {
			synchronized (object) {
				System.out.println("线程" + Thread.currentThread().getName()
						+ "获取到了锁...");
				try {
					System.out.println("线程" + Thread.currentThread().getName()
							+ "阻塞并释放锁...");
					object.wait();
				} catch (InterruptedException e) {
				}
				System.out.println("线程" + Thread.currentThread().getName()
						+ "执行完成...");
			}
		}
	}

	static class Thread2 extends Thread {
		@Override
		public void run() {
			synchronized (object) {
				System.out.println("线程" + Thread.currentThread().getName()
						+ "获取到了锁...");
				object.notify();
				System.out.println("线程" + Thread.currentThread().getName()
						+ "唤醒了正在wait的线程...");
			}
			System.out
					.println("线程" + Thread.currentThread().getName() + "执行完成...");
		}
	}
}/* Output: 
        线程Thread-0获取到了锁...
        线程Thread-0阻塞并释放锁...
        线程Thread-1获取到了锁...
        线程Thread-1唤醒了正在wait的线程...
        线程Thread-1执行完成...
        线程Thread-0执行完成...
 *///:~

三. Condition

// 线程 A
class ThreadA extends Thread {
	private MyService service;
	public ThreadA(MyService service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.awaitA();
	}
}
// 线程 B
class ThreadB extends Thread {
	public ThreadB(MyService service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.awaitB();
	}
}

class MyService {
	private Lock lock = new ReentrantLock();
	// 使用多个Condition实现通知部分线程
	public Condition conditionA = lock.newCondition();
	public Condition conditionB = lock.newCondition();

	public void awaitA() {
	    lock.lock();
	    try {
		    System.out.println("begin awaitA时间为" + System.currentTimeMillis()
			    	+ " ThreadName=" + Thread.currentThread().getName());
		    conditionA.await();
		    System.out.println("  end awaitA时间为" + System.currentTimeMillis()
			    	+ " ThreadName=" + Thread.currentThread().getName());
	    } catch (InterruptedException e) {
		    e.printStackTrace();
	    } finally {
		    lock.unlock();
	    }
    }

	public void awaitB() {
	    lock.lock();
		try {
			System.out.println("begin awaitB时间为" + System.currentTimeMillis()
					+ " ThreadName=" + Thread.currentThread().getName());
			conditionB.await();
			System.out.println("  end awaitB时间为" + System.currentTimeMillis()
					+ " ThreadName=" + Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void signalAll_A() {
		try {
			lock.lock();
			System.out.println("  signalAll_A时间为" + System.currentTimeMillis()
					+ " ThreadName=" + Thread.currentThread().getName());
			conditionA.signalAll();
		} finally {
			lock.unlock();
		}
	}

	public void signalAll_B() {
		try {
			lock.lock();
			System.out.println("  signalAll_B时间为" + System.currentTimeMillis()
					+ " ThreadName=" + Thread.currentThread().getName());
			conditionB.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

// 测试
public class Run {
	public static void main(String[] args) throws InterruptedException {
	    MyService service = new MyService();

	    ThreadA a = new ThreadA(service);
	    a.setName("A");
	    a.start();

    	ThreadB b = new ThreadB(service);
	    b.setName("B");
    	b.start();

	    Thread.sleep(3000);
	    service.signalAll_A();
    }
}

实现一个死锁

public class Tr1 implements Runnable {
	
	Object lock;
	Object lock2;

	public Tr1(Object lock,Object lock2){
		this.lock= lock;
		this.lock2= lock2;
	}
	@Override
	public void run() {
	    //获取lock
		synchronized (lock) {
			System.out.println(Thread.currentThread().getName()+"获取了lock锁");
			try {
				Thread.sleep(3000);
			} catch (Exception e) {
			}
			//获取lock2
			synchronized (lock2) {
				System.out.println(Thread.currentThread().getName()+"获取了lock2锁");
			}
		}
		
	}
}


public class Tr2 implements Runnable {
	
	Object lock;
	Object lock2;

	public Tr2(Object lock,Object lock2){
		this.lock= lock;
		this.lock2= lock2;
	}
	@Override
	public void run() {
	    //获取lock2
		synchronized (lock2) {
			System.out.println(Thread.currentThread().getName()+"获取了lock2锁");
			try {
				Thread.sleep(3000);
			} catch (Exception e) {
			}
			//获取lock
			synchronized (lock) {
				System.out.println(Thread.currentThread().getName()+"获取了lock锁");
			}
		}
		
	}
}

public class test {
    public static void mian(ars [] a) {
          Object lock=new Object();
          Object lock2=new Object();

          Tr1 tr1=new Tr1(lock, lock2);
          Tr2 tr2=new Tr2(lock, lock2);
		
          Thread t1=new Thread(tr1);
          Thread t2=new Thread(tr2);

          t1.start();
          t2.start();
    }
}

Mybatis初始化和执行原理

Spring mvc初始化和执行原理

Springboot如何自定义starter(https://juejin.im/post/5c81dda6e51d4539ab383e3a)

我们需要先创建两个工程 hello-spring-boot-starter 和 hello-spring-boot-starter-autoconfigurer

1. hello-spring-boot-starter

1.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.gf</groupId>
	<artifactId>hello-spring-boot-starter</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>hello-spring-boot-starter</name>

	<!-- 启动器 -->
	<dependencies>
		<!-- 引入自动配置模块 -->
		<dependency>
			<groupId>com.gf</groupId>
			<artifactId>hello-spring-boot-starter-autoconfigurer</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>


</project>

同时删除启动类、resources下的文件，test文件。

2. hello-spring-boot-starter-autoconfigurer

1. pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.gf</groupId>
	<artifactId>hello-spring-boot-starter-autoconfigurer</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>hello-spring-boot-starter-autoconfigurer</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<!-- 引入spring-boot-starter，所有starter的基本配合 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

	</dependencies>


</project>

2. HelloProperties

package com.gf.service;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "gf.hello")
public class HelloProperties {

    private String prefix;
    private String suffix;

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }

}

3. HelloService

package com.gf.service;


public class HelloService {

    HelloProperties helloProperties;

    public HelloProperties getHelloProperties() {
        return helloProperties;
    }

    public void setHelloProperties(HelloProperties helloProperties) {
        this.helloProperties = helloProperties;
    }

    public String sayHello(String name ) {
        return helloProperties.getPrefix()+ "-" + name + helloProperties.getSuffix();
    }
}

4. HelloServiceAutoConfiguration

package com.gf.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnWebApplication //web应该生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {

    @Autowired
    HelloProperties helloProperties;

    @Bean
    public HelloService helloService() {
        HelloService service = new HelloService();
        service.setHelloProperties( helloProperties  );
        return service;
    }


}

5. spring.factories

在 resources 下创建文件夹 META-INF 并在 META-INF 下创建文件 spring.factories ，内容如下：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.gf.service.HelloServiceAutoConfiguration
复制代码

到这儿，我们的配置自定义的starter就写完了，我们把 hello-spring-boot-starter-autoconfigurer、hello-spring-boot-starter 安装成本地jar包。

Redis数据类型

Redis支持5种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。何时使用Redis呢?

Redis淘汰策略

当前Redis3.0版本支持的淘汰策略有6种：

volatile-lru：从设置过期时间的数据集(server.db[i].expires)中挑选出最近最少使用的数据淘汰。没有设置过期时间的key不会被淘汰，这样就可以在增加内存空间的同时保证需要持久化的数据不会丢失。
volatile-ttl：除了淘汰机制采用LRU，策略基本上与volatile-lru相似，从设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰，ttl值越大越优先被淘汰。
volatile-random：从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰。当内存达到限制无法写入非过期时间的数据集时，可以通过该淘汰策略在主键空间中随机移除某个key。
allkeys-lru：从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰，该策略要淘汰的key面向的是全体key集合，而非过期的key集合。
allkeys-random：从数据集(server.db[i].dict)中选择任意数据淘汰。
no-enviction：禁止驱逐数据，也就是当内存不足以容纳新入数据时，新写入操作就会报错，请求可以继续进行，线上任务也不能持续进行，采用no-enviction策略可以保证数据不被丢失，这也是系统默认的一种淘汰策略。

Redis集群方式

主从复制
哨兵模式
Redis-Cluster集群

MySQL数据库引擎比较

InnoDB：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。
MyISAM：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比较低，也可以使用。
MEMORY：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。所以，这类数据库只使用在相对较小的数据库表。

事务隔离级别说明

未提交读(Read Uncommitted)：脏读,不可重复读, 幻读;也就是可能读取到其他会话中未提交事务修改的数据
提交读(Read Committed)：不可重复读, 幻读;只能读取到已经提交的数据。多数数据库默认都是该级别 (不重复读)
可重复读(Repeated Read)：幻读;在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读
串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞

项目中使用哪些设计模式？

（策略，单例，工厂）

批量导出的业务1000个，如何实现

（多线程、压缩传输）

什么场景会出现栈溢出

栈溢出抛出java.lang.StackOverflowError错误，出现此种情况是因为方法运行的时候，请求新建栈帧时，

栈所剩空间小于战帧所需空间。

例如，通过递归调用方法,不停的产生栈帧,一直把栈空间堆满,直到抛出异常：


package com.jvm;
/**
 * 栈溢出
 * @author feizi
 * @time 2015-1-23上午9:13:11
 */
public class SOFTest {
 
	public void stackOverFlowMethod(){
		stackOverFlowMethod();
	}
	
	/**
	 * 通过递归调用方法,不停的产生栈帧,一直把栈空间堆满,直到抛出异常 ：
	 * @param args
	 */
	public static void main(String[] args) {
		SOFTest sof = new SOFTest();
		sof.stackOverFlowMethod();
	}
 

}

一般怎么优化慢查询

优化sql,建立索引

什么情况下会使得索引失效

1．隐式转换导致索引失效.这一点应当引起重视.也是开发中经常会犯的错误.

由于表的字段tu_mdn定义为varchar2(20),但在查询时把该字段作为number类型以where条件传给Oracle,这样会导致索引失效.

错误的例子：select * fromtest where tu_mdn=13333333333;

正确的例子：select * fromtest where tu_mdn='13333333333';
2.对索引列进行运算导致索引失效,我所指的对索引列进行运算包括(+，-，*，/，! 等)

错误的例子：select* from test where id-1=9;

正确的例子：select * fromtest where id=10;

3.使用Oracle内部函数导致索引失效.对于这样情况应当创建基于函数的索引.

错误的例子：select * from test where round(id)=10;说明，此时id的索引已经不起作用了

正确的例子：首先建立函数索引，create index test_id_fbi_idx on test(round(id));然后select * from test where round(id)=10; 这时函数索引起作用了

4.以下使用会使索引失效，应避免使用；

a. 使用 <> 、not in、not exist、!=

b. like "%_"百分号在前（可采用在建立索引时用reverse(columnName)这种方法处理）

c. 单独引用复合索引里非第一位置的索引列.应总是使用索引的第一个列，如果索引是建立在多个列上,只有在它的第一个列被 where子句引用时，优化器才会选择使用该索引。

d.字符型字段为数字时在where条件里不添加引号.

e.当变量采用的是times变量，而表的字段采用的是date变量时.或相反情况。

5. 不要将空的变量值直接与比较运算符（符号）比较。

如果变量可能为空，应使用 IS NULL 或 IS NOT NULL 进行比较，或者使用 ISNULL函数。

6. 不要在 SQL 代码中使用双引号。

因为字符常量使用单引号。如果没有必要限定对象名称，可以使用（非 ANSI SQL标准）括号将名称括起来。

7.将索引所在表空间和数据所在表空间分别设于不同的磁盘chunk上，有助于提高索引查询的效率。

8.Oracle默认使用的基于代价的SQL优化器（CBO）非常依赖于统计信息，一旦统计信息不正常，会导致数据库查询时不使用索引或使用错误的索引。

一般来说，Oracle的自动任务里面会包含更新统计信息的语句，但如果表数据发生了比较大的变化（超过20%）,可以考虑立即手动更新统计信息，例如：analyze table abc computestatistics，但注意，更新统计信息比较耗费系统资源，建议在系统空闲时执行。

9. Oracle在进行一次查询时，一般对一个表只会使用一个索引.

因此，有时候过多的索引可能导致Oracle使用错误的索引，降低查询效率。例如某表有索引1（Policyno）和索引2（classcode），如果查询条件为policyno = ‘xx’ and classcode = ‘xx’，则系统有可能会使用索引2，相较于使用索引1，查询效率明显降低。

10. 优先且尽可能使用分区索引。

Redis分布式锁中加锁与解锁的详细细节询问

1.加锁

最简单的方法是使用setnx命令。key是锁的唯一标识，按业务来决定命名，value为当前线程的线程ID。比如想要给一种商品的秒杀活动加锁，可以给key命名为 “lock_sale_ID” 。而value设置成什么呢？我们可以姑且设置成1。加锁的伪代码如下： setnx（key，1）当一个线程执行setnx返回1，说明key原本不存在，该线程成功得到了锁，当其他线程执行setnx返回0，说明key已经存在，该线程抢锁失败。

2.解锁

有加锁就得有解锁。当得到锁的线程执行完任务，需要释放锁，以便其他线程可以进入。释放锁的最简单方式是执行del指令，伪代码如下：del（key）释放锁之后，其他线程就可以继续执行setnx命令来获得锁。

Spring的ApplicationEvent的使用场景

配合监听器使用

SpringMVC拦截器和过滤器区别

拦截器是基于java的反射机制的，而过滤器是基于函数回调。
拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

一个项目中可以有多个dispatcherServelt吗？为什么？

使用Spring MVC,配置DispatcherServlet是第一步。

DispatcherServlet是一个Servlet,所以可以配置多个DispatcherServlet。

DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller(我们写的Action)来处理。

SpringAOP涉及到什么设计模式？底层原理

oop设计模式

1、JDK动态代理
2、Cglib动态代理

SpringBoot配置文件加载优先级

file:./config/ (当前项目路径config目录下);
file:./ (当前项目路径下);
classpath:/config/ (类路径config目录下);
classpath:/ (类路径config下).

ArrayList底层原理

辰小影

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java面试题目解答

由于自己知识量不足,特意到处总结资料统计Switch数据类型支持哪些基本数据类型：byte, short, char, int 包装数据类型：Byte, Short, Character, Integer 枚举类型：Enum 字符串类型：String（Jdk 7+ 开始支持） Java有哪些锁？公平锁/非公平锁可重入锁独享锁/共享锁互斥锁/读写锁乐观锁/悲观锁分段锁偏向锁/轻量级锁/重量级锁自旋锁Java内存模...
复制链接

扫一扫