搜索到
33
篇与
的结果
-
![[转载]:Java 相关一些面试题](https://npm.elemecdn.com/typecho-joe-latest/assets/img/lazyload.jpg)
[转载]:Java 相关一些面试题 junit 用法，before,beforeClass,after, afterClass 的执行顺序分布式锁nginx 的请求转发算法，如何配置根据权重转发用 hashmap 实现 redis 有什么问题（死锁，死循环，可用 ConcurrentHashmap）线程的状态线程的阻塞的方式sleep 和 wait 的区别hashmap 的底层实现一万个人抢 100 个红包，如何实现（不用队列），如何保证 2 个人不能抢到同一个红包，可用分布式锁java 内存模型，垃圾回收机制，不可达算法两个 Integer 的引用对象传给一个 swap 方法在方法内部交换引用，返回后，两个引用的值是否会发现变化aop 的底层实现，动态代理是如何动态，假如有 100 个对象，如何动态的为这 100 个对象代理是否用过 maven install。 maven test。git（make install 是安装本地 jar 包）tomcat 的各种配置，如何配置 docBasespring 的 bean 配置的几种方式web.xml 的配置spring 的监听器。zookeeper 的实现机制，有缓存，如何存储注册服务的IO 会阻塞吗？readLine 是不是阻塞的用过 spring 的线程池还是 java 的线程池？字符串的格式化方法 （20，21 这两个问题问的太低级了）时间的格式化方法定时器用什么做的线程如何退出结束java 有哪些锁？乐观锁 悲观锁 synchronized 可重入锁 读写锁，用过 reentrantlock 吗？reentrantlock 与 synmchronized 的区别ThreadLocal 的使用场景java 的内存模型，垃圾回收机制为什么线程执行要调用 start 而不是直接 run（直接 run，跟普通方法没什么区别，先调 start，run 才会作为一个线程方法运行）qmq 消息的实现机制 (qmq 是去哪儿网自己封装的消息队列)遍历 hashmap 的三种方式jvm 的一些命令memcache 和 redis 的区别mysql 的行级锁加在哪个位置ConcurrentHashmap 的锁是如何加的？是不是分段越多越好myisam 和 innodb 的区别（innodb 是行级锁，myisam 是表级锁）mysql 其他的性能优化方式linux 系统日志在哪里看如何查看网络进程统计一个整数的二进制表示中 bit 为 1 的个数jvm 内存模型，java 内存模型如何把 java 内存的数据全部 dump 出来如何手动触发全量回收垃圾，如何立即触发垃圾回收hashmap 如果只有一个写其他全读会出什么问题git rebasemongodb 和 hbase 的区别如何解决并发问题volatile 的用途java 线程池（好像之前我的理解有问题）mysql 的 binlog代理模式mysql 是如何实现事务的读写分离何时强制要读主库，读哪个从库是通过什么方式决定的，从库的同步 mysql 用的什么方式mysql 的存储引擎mysql 的默认隔离级别，其他隔离级别将一个链表反转（用三个指针，但是每次只发转一个）spring Aop 的实现原理，具体说说何时会内存泄漏，内存泄漏会抛哪些异常是否用过 Autowire 注解spring 的注入 bean 的方式sql 语句各种条件的执行顺序，如 select， where， order by， group byselect xx from xx where xx and xx order by xx limit xx； 如何优化这个（看 explain）四则元算写代码统计 100G 的 ip 文件中出现 ip 次数最多的 100 个 ipzookeeper 的事物，结点，服务提供方挂了如何告知消费方5 台服务器如何选出 leader (选举算法)适配器和代理模式的区别读写锁static 加锁事务隔离级别门面模式，类图 (外观模式)mybatis 如何映射表结构二叉树遍历主从复制mysql 引擎区别静态内部类加载到了哪个区？方法区class 文件编译后加载到了哪web 的 http 请求如何整体响应时间变长导致处理的请求数变少，该如何处理？用队列，当处理不了那么多 http 请求时将请求放到队列中慢慢处理，web 如何实现队列线程安全的单例模式快速排序性能考虑volatile 关键字用法求表的 size，或做数据统计可用什么存储引擎读多写少可用什么引擎假如要统计多个表应该用什么引擎concurrenhashmap 求 size 是如何加锁的，如果刚求完一段后这段发生了变化该如何处理1000 个苹果放 10 个篮子，怎么放，能让我拿到所有可能的个数可重入的读写锁，可重入是如何实现的？是否用过 NIOjava 的 concurrent 包用过没sting s=new string (“abc”) 分别在堆栈上新建了哪些对象java 虚拟机的区域分配，各区分别存什么分布式事务（JTA）threadlocal 使用时注意的问题（ThreadLocal 和 Synchonized 都用于解决多线程并发访问。但是 ThreadLocal 与 synchronized 有本质的区别。synchronized 是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而 ThreadLocal 为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而 Synchronized 却正好相反，它用于在多个线程间通信时能够获得数据共享）java 有哪些容器 (集合，tomcat 也是一种容器)二分查找算法myisam 的优点，和 innodb 的区别redis 能存哪些类型http 协议格式，get 和 post 的区别可重入锁中对应的 wait 和 notifyredis 能把内存空间交换进磁盘中吗 (这个应该是可以的，但是那个面试官非跟我说不可以)java 线程池中基于缓存和基于定长的两种线程池，当请求太多时分别是如何处理的？定长的事用的队列，如果队列也满了呢？交换进磁盘？基于缓存的线程池解决方法呢？synchronized 加在方法上用的什么锁可重入锁中的 lock 和 trylock 的区别innodb 对一行数据的读会枷锁吗？不枷锁，读实际读的是副本redis 做缓存是分布式存的？不同的服务器上存的数据是否重复？guavacache 呢？是否重复？不同的机器存的数据不同用 awk 统计一个 ip 文件中 top10对表做统计时可直接看 schema info 信息，即查看表的系统信息mysql 目前用的版本公司经验丰富的人给了什么帮助？(一般 boss 面会问这些)自己相对于一样的应届生有什么优势自己的好的总结习惯给自己今后的工作带了什么帮助，举例为证原子类，线程安全的对象，异常的处理方式4 亿个 int 数，如何找出重复的数（用 hash 方法，建一个 2 的 32 次方个 bit 的 hash 数组，每取一个 int 数，可 hash 下 2 的 32 次方找到它在 hash 数组中的位置，然后将 bit 置 1 表示已存在）4 亿个 url，找出其中重复的（考虑内存不够，通过 hash 算法，将 url 分配到 1000 个文件中，不同的文件间肯定就不会重复了，再分别找出重复的）有 1 万个数组，每个数组有 1000 个整数，每个数组都是降序的，从中找出最大的 N 个数，N<1000LinkedHashmap 的底层实现类序列化时类的版本号的用途，如果没有指定一个版本号，系统是怎么处理的？如果加了字段会怎么样？Override 和 Overload 的区别，分别用在什么场景java 的反射是如何实现的参考资料Java 相关一些面试题 -
设计模式学习笔记2：单例模式 1.介绍单例模式的定义就是确保某一个类只有一个实例，并且提供一个全局访问点。这种类型的设计模式属于创建型模式。单例模式具有典型的三个特点：只有一个实例。自我实例化。提供全局访问点。应用实例：1、一个班级只有一个班主任。2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。优点：1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。2、避免对资源的多重占用（比如写文件操作）。缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。使用场景：1、要求生产唯一序列号。2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。2.几种实现方式2.1 懒汉式，线程不安全是否 Lazy 初始化：是是否多线程安全：否描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。// 懒汉式单例 public class LazyMan { // 1.私有化构造函数 private LazyMan(){} // 2.先定义单例对象但不实例化 private static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ if (lazyMan==null){ lazyMan = new LazyMan(); } return lazyMan; } }2.2 懒汉式，线程安全是否 Lazy 初始化：是是否多线程安全：是描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。优点：第一次调用才初始化，避免内存浪费。缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。// 懒汉式单例 public class LazyMan { // 1.私有化构造函数 private LazyMan(){} // 2.先定义单例对象但不实例化 private static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static synchronized LazyMan getInstance(){ if (lazyMan==null){ lazyMan = new LazyMan(); } return lazyMan; } }2.3 饿汉式是否 Lazy 初始化：否是否多线程安全：是描述：这种方式比较常用，但容易产生垃圾对象。优点：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。// 饿汉式单例模式 public class Hungry { // 1.私有化构造函数 private Hungry(){} // 2.事先创建好对象 private final static Hungry HUNGRY = new Hungry(); // 3.当需要调用的单例对象的时候通过暴露的公有的方法进行调用 public static Hungry getInstance(){ return HUNGRY; } }2.4 双检锁/双重校验锁（DCL，即 double-checked locking）/DCL懒汉式单例是否 Lazy 初始化：是是否多线程安全：是实现难度：较复杂描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。// 懒汉式单例 public class LazyMan { // 1.私有化构造函数 private LazyMan(){} // 2.先定义单例对象但不实例化 private volatile static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ // 双重检测锁模式的懒汉式单例 DCL懒汉式 if (lazyMan==null){ synchronized (LazyMan.class){ if (lazyMan==null){ lazyMan = new LazyMan(); } } } return lazyMan; } }为什么要加volatilelazyMan = new LazyMan(); // 不是一个原子性操作创建对象的过程不是一个原子操作，分为以下3步:1.分配内存空间2.执行构造方法，初始化对象3.把这个对象指向这个空间在执行的过程中可能会发生指令重排的现象，即我们真实想要的执行顺序是1->2->3。但是可能真实的执行顺序是1->3->2。则当线程A以1->3->2的顺序执行到3时，线程B也调用了返回对象实例的方法，则给线程B可能拿到未创建完成的对象进行调用从而导致出错。2.5 登记式/静态内部类是否 Lazy 初始化：是是否多线程安全：是描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。public class Singleton { private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } private Singleton (){} public static final Singleton getInstance() { return SingletonHolder.INSTANCE; } }2.6 枚举描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。public enum Singleton { INSTANCE; public void whateverMethod() { } }3.反射下的单例模式3.1 V1：在单例类已经实例化了对象的条件下使用反射破坏单例3.1.1 示例package single; import java.lang.reflect.Constructor; // 懒汉式单例 public class LazyMan { // 1.私有化构造函数 private LazyMan(){} // 2.先定义单例对象但不实例化 private volatile static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ // 双重检测锁模式的懒汉式单例 DCL懒汉式 if (lazyMan==null){ synchronized (LazyMan.class){ if (lazyMan==null){ lazyMan = new LazyMan(); } } } return lazyMan; } public static void main(String[] args) throws Exception { LazyMan instance1 = LazyMan.getInstance(); // 获取空参构造器 Constructor<LazyMan> declareConstructor = LazyMan.class.getDeclaredConstructor(null); // 将空参构造器的Accessible设置为true declareConstructor.setAccessible(true); // 调用空参构造器实例化对象 LazyMan instance2 = declareConstructor.newInstance(); System.out.println(instance1); System.out.println(instance2); } } single.LazyMan@1b6d3586 single.LazyMan@4554617c3.1.2 防止措施通过在构造函数中加入一个同步代码块进行一次是否已经生成了该单例类对象的判断package single; import java.lang.reflect.Constructor; // 懒汉式单例 public class LazyMan { // 1.私有化构造函数 private LazyMan(){ synchronized (LazyMan.class){ if(lazyMan!=null){ throw new RuntimeException("不要试图使用反射破坏单例模式"); } } } // 2.先定义单例对象但不实例化 private volatile static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ // 双重检测锁模式的懒汉式单例 DCL懒汉式 if (lazyMan==null){ synchronized (LazyMan.class){ if (lazyMan==null){ lazyMan = new LazyMan(); } } } return lazyMan; } public static void main(String[] args) throws Exception { LazyMan instance1 = LazyMan.getInstance(); // 获取空参构造器 Constructor<LazyMan> declareConstructor = LazyMan.class.getDeclaredConstructor(null); // 将空参构造器的Accessible设置为true declareConstructor.setAccessible(true); // 调用空参构造器实例化对象 LazyMan instance2 = declareConstructor.newInstance(); System.out.println(instance1); System.out.println(instance2); } }Exception in thread "main" java.lang.reflect.InvocationTargetException at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:423) at single.LazyMan.main(LazyMan.java:38) Caused by: java.lang.RuntimeException: 不要试图使用反射破坏单例模式 at single.LazyMan.<init>(LazyMan.java:11) ... 5 more3.2 V2：V1解决方案破解3.2.1 示例package single; import java.lang.reflect.Constructor; // 懒汉式单例 public class LazyMan { // 1.私有化构造函数 private LazyMan(){ synchronized (LazyMan.class){ if(lazyMan!=null){ throw new RuntimeException("不要试图使用反射破坏单例模式"); } } } // 2.先定义单例对象但不实例化 private volatile static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ // 双重检测锁模式的懒汉式单例 DCL懒汉式 if (lazyMan==null){ synchronized (LazyMan.class){ if (lazyMan==null){ lazyMan = new LazyMan(); } } } return lazyMan; } public static void main(String[] args) throws Exception { // 获取空参构造器 Constructor<LazyMan> declareConstructor = LazyMan.class.getDeclaredConstructor(null); // 将空参构造器的Accessible设置为true declareConstructor.setAccessible(true); // 调用空参构造器实例化对象 LazyMan instance1 = declareConstructor.newInstance(); LazyMan instance2 = declareConstructor.newInstance(); System.out.println(instance1); System.out.println(instance2); } }3.2.2 防止措施--"红绿灯策略''，设置标志位package single; import java.lang.reflect.Constructor; // 懒汉式单例 public class LazyMan { private static boolean flag = false; // 1.私有化构造函数 private LazyMan(){ synchronized (LazyMan.class){ if(flag == false){ flag = true; }else{ throw new RuntimeException("不要试图使用反射破坏单例模式"); } } } // 2.先定义单例对象但不实例化 private volatile static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ // 双重检测锁模式的懒汉式单例 DCL懒汉式 if (lazyMan==null){ synchronized (LazyMan.class){ if (lazyMan==null){ lazyMan = new LazyMan(); } } } return lazyMan; } public static void main(String[] args) throws Exception { // 获取空参构造器 Constructor<LazyMan> declareConstructor = LazyMan.class.getDeclaredConstructor(null); // 将空参构造器的Accessible设置为true declareConstructor.setAccessible(true); // 调用空参构造器实例化对象 LazyMan instance1 = declareConstructor.newInstance(); LazyMan instance2 = declareConstructor.newInstance(); System.out.println(instance1); System.out.println(instance2); } }3.3 V3：V2解决方案破解3.3.1 示例对字节码进行反编译获取到标志位，然后使用反射破解"红路灯"标志位package single; import java.lang.reflect.Constructor; import java.lang.reflect.Field; // 懒汉式单例 public class LazyMan { private static boolean flag = false; // 1.私有化构造函数 private LazyMan(){ synchronized (LazyMan.class){ if(flag == false){ flag = true; }else{ throw new RuntimeException("不要试图使用反射破坏单例模式"); } } } // 2.先定义单例对象但不实例化 private volatile static LazyMan lazyMan; // 3.当发起调用的时候判断对象是否实例化，如果未实例化，则实例化再返回，否则直接返回 public static LazyMan getInstance(){ // 双重检测锁模式的懒汉式单例 DCL懒汉式 if (lazyMan==null){ synchronized (LazyMan.class){ if (lazyMan==null){ lazyMan = new LazyMan(); } } } return lazyMan; } public static void main(String[] args) throws Exception { // 获取空参构造器 Constructor<LazyMan> declareConstructor = LazyMan.class.getDeclaredConstructor(null); // 将空参构造器的Accessible设置为true declareConstructor.setAccessible(true); // 调用空参构造器实例化对象 LazyMan instance1 = declareConstructor.newInstance(); // 获取"红绿灯标志位" Field flag = LazyMan.class.getDeclaredField("flag"); // 重置为"绿灯" flag.set(instance1,false); LazyMan instance2 = declareConstructor.newInstance(); System.out.println(instance1); System.out.println(instance2); } }single.LazyMan@4554617c single.LazyMan@74a144823.3.2 防止措施-使用枚举Enum实现单例模式import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; enum EnumSingle { INSTANCE; public EnumSingle getInstance(){ return INSTANCE; } } public class Test{ public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException { EnumSingle instance1 = EnumSingle.INSTANCE; Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class); declaredConstructor.setAccessible(true); EnumSingle instance2 = declaredConstructor.newInstance(); System.out.println(instance1); System.out.println(instance2); } }Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417) at single.Test.main(EnumSingle.java:20)参考资料【狂神说Java】单例模式-23种设计模式系列单例模式Java中的双重检查锁（double checked locking） Java设计模式（一）之单例模式
-
设计模式学习笔记1：设计模式概述 1.什么是设计模式设计模式的概念最早是由 克⾥斯托佛·亚历⼭⼤ 在其著作 《建筑模式语⾔》 中⾸次提出的。 该书介绍了城市设计的 “语⾔”，提供了253个描述城镇、邻⾥、住宅、花园、房间及⻄部构造的模式， ⽽此类“语⾔” 的基本单元就是模式。后来， 埃⾥希·伽玛 、 约翰·弗利赛德斯 、 拉尔夫·约翰逊 和 理查德·赫尔姆 这四位大佬即GoF（Gang of Four，四人组/四人帮）接受了模式的概念。 1995 年， 他们出版了 《设计模式： 可复⽤⾯向对象软件的基础》⼀书，将设计模式的概念应⽤到程序开发领域中。该书 共收录了23种设计模式，从此树立了软件设计模式领域的里程碑，人称GoF设计模式。简单来说，设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。2.学习设计模式的意义设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。正确使用设计模式具有以下优点：可以提高程序员的思维能力、编程能力和设计能力。使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。3.设计模式的基本要素4.GoF 23创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。结构型模式：适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式行为型模式：模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式，职责链模式，访问者模式。5.OOP七大原则开闭原则：对扩展开放，对修改关闭里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立依赖倒置原则：要面向接口编程，不要面向实现编程。单一职责原则：控制类的粒度大小、将对象解耦、提高其内聚性。接口隔离原则：要为各个类建立它们需要的专用接口。迪米特法则：只与你的直接朋友交谈，不跟"陌生人"说话。合成复用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。参考资料【狂神说Java】通俗易懂的23种设计模式教学（停更）设计模式简介
![[转载]:Java 相关一些面试题](https://blog.inat.top/usr/themes/Joe/assets/thumb/22.jpg)
