一 基础
关键字
synchronized：修饰方法 代码块，原子性 可见性 有序性（在锁的部分会详细说明）
volatile：修饰全局变量，可见性 有序性 （在并发部分会详细说明）
transient：修饰全局变量，序列化对象的时候，这个属性就不会被序列化
为什么重写equals要重写hashCode
重写hashCode要保证 相同的对象有相同的hashCode ，但是相同的hashCode对象可能不相同
Set HashMap这些利用hash的数据结构在新增元素时首先会判断hashCode
如果hashCode 不同 直接会新增元素，如果hashCode相同会再去比对equals
Java中hashCode默认返回的是内存地址，即使内容相同但是地址不同就会判定不是同一个对象
所以一般重写equals的时候需要重写hashCode
Clone
java中的clone是Object中的方法
protected native Object clone() throws CloneNotSupportedException;如果需要对象能够clone 必须要实现 java.lang.Cloneable接口 该接口是个空接口没有任何抽象方法
拷贝分为深拷贝和浅拷贝
浅拷贝就是拷贝出来的对象的引用属性与源对象的引用属性是同一个地址的数据（主要是引用类型，基本类型没有更改）
深拷贝就是拷贝出来的对象的引用属性是源对象引用属性的拷贝（需要自己实现）
二 强软弱虚
JAVA引用分为四种
强引用：开发过程中的变量指向就是强引用，如果有引用即使OOM GC也不会回收
软引用：需要使用SoftReference包装，在内存不足时GC会回收掉该包装对象
弱引用：需要使用WeakReference包装，只要GC就会回收掉该包装对象
虚引用：需要使用PhantomReference包装，任何时候返回都是null，需要跟ReferenceQueue搭配使用，如果被回收就会放入队列
//配置启动参数 -Xms1M -Xmx1M
public class ReferenceTest {
//防止创建的对象逃逸分析在栈上创建
static ArrayList<Object> objects = new ArrayList<>();
public static void main(String[] args) throws InterruptedException {
//强引用
Object a = new Object();
System.out.println("hard Reference:" + a);
System.gc();
System.out.println("hard Reference gc:" + a);
System.out.println();
//软引用
SoftReference softReference = new SoftReference(new Object());
System.out.println("softReference:" + softReference.get());
System.gc();
System.out.println("softReference gc:" + softReference.get());
System.out.println();
//弱引用 只要gc就会被回收
WeakReference weakReference = new WeakReference(new Object());
System.out.println("weakReference:" + weakReference.get());
System.gc();
System.out.println("weakReference gc:" + weakReference.get());
System.out.println();
//虚引用 任何时候都会返回null 必须和队列搭配使用 如果被垃圾回收会把引用放入队列
ReferenceQueue referenceQueue = new ReferenceQueue();
PhantomReference phantomReference = new PhantomReference(new Object(), referenceQueue);
System.out.println("phantomReference:" + phantomReference.get());
System.gc();
System.out.println("phantomReference queue gc:" + referenceQueue.remove());
System.out.println();
a = null;
weakReference = null;
phantomReference = null;
referenceQueue = null;
System.gc();
//当内存不足时 gc才会回收软引用
System.out.println("softReference:" + softReference.get());
for (;;){
objects.add(new byte[100000]);
System.gc();
System.out.println(Runtime.getRuntime().freeMemory());
System.out.println("softReference gc:" + softReference.get());
}
}
}
三 ThreadLocal
ThreadLoacal是一个数据缓存区，只要是同一个线程同一个ThradLocal就可以获取到同一块内存区域的数据
ThreadLocal主要有三个API：get() set(T t) remove()
public class ThreadLocal<T> {
public T get() {
//获取当前线程
Thread t = Thread.currentThread();
//获取真正存储数据的Map，该map维护在Thread
ThreadLocalMap map = getMap(t);
if (map != null) {
//获取key是当前ThreadLocal的Entry
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
//如果map == null 或者map中没有当前ThreadLocal
return setInitialValue();
}
//返回线程中的ThreadLocal.ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//初始化Map 返回null
private T setInitialValue() {
//返回一个null
T value = initialValue();
//获取当前线程
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
//放入null
map.set(this, value);
else
//初始化map，放入null
createMap(t, value);
return value;
}
//给当前Thread new一个ThreadLocalMap，并放入value
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
public void set(T value) {
//获取当前线程的ThreadLocalMap
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
//赋值
map.set(this, value);
else
//初始化并赋值
createMap(t, value);
}
public void remove() {
//获取当前线程的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
//移除key为当前ThreadLocal的entry
if (m != null)
m.remove(this);
}
}
//Thread类
public class Thread implements Runnable {
//Thread维护的Map
ThreadLocal.ThreadLocalMap threadLocals = null;
}内存泄漏
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal> {
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
}
从上面可以看出 ThreadLocalMap中的Entry是WeakReference
这样做的目的是因为ThreadLocal使用完毕设为null之后 可能内存不足经过GC回收
但是Thread还在阻塞 或者线程池的方式就会出现
Thread--》ThreadLocalMap--》Entry--》ThreadLocal的引用
造成ThreadLocal不会被真正回收
还有一种情况就是
WeakReference包装的ThreadLocal被回收了
线程一直在运行
但是由于Thread--》ThreadLocalMap--》Entry--》Value的引用
造成value不会被回收 但是ThreadLocal被回收没有办法通过ThreadLocal获取也不能置为null
所以使用完毕最好收动remove下
四 字符串
在JAVA中String类是被final修饰的同时String是不可修改的，每次的引用都会创建新的字符串
stringbuilder和stringbuffer区别
String，StringBuffer，StringBuilder。区别String声明的是不可变的对象，每次操作必然产生一个新的对象；StringBuffer和StringBuilder都继承自抽象类AbstractStringBuilder；StringBuffer具备线程安全性；
在使用场景上，并发必选StringBuffer，迭代必选StringBuilder，普通场景选String，避免中途不必要的类型转换开销。
//StringBuilder 线程不安全
public StringBuilder append(String str) {
super.append(str);
return this;
}
//StringBuffer 线程安全
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}String的intern()
intern方法是返回字符串在常量池中的对象
JDK1.7之前 字符串常量池存在方法区
JDK1.7及之后 字符串常量池存在堆
intern方法在1.7之前
如果存在直接返回引用，如果常量池不存在会复制一份该字符串到常量池并返回复制的字符串地址
intern方法在1.7及之后
如果存在直接返回引用，如果常量池不存在会复制该字符串到引用到常量池然后返回
下面出现false的原因是 1.7.0_51这个字符串已经在常量池存在了，所以返回的是已经存在的引用而不是a的引用 结果当然是false 这个在sun.misc.Version中可以看到 你的Java版本这个字符串
有兴趣的可以自己搜索一下JVM底层的实现
五 类加载器
基本概念
JAVA中类加载器可以分为4类
Bootstrap ClassLoader（根加载器）
它用来加载 Java 的核心类，是用原生代码来实现的，并不继承自 java.lang.ClassLoader（负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类
Extension ClassLoader（扩展类载器）
它负责加载JRE的扩展目录，lib/ext或者由java.ext.dirs系统属性指定的目录中的JAR包的类。由Java语言实现，父类加载器为bootstrap classloader，由于bootstrap classloader不是java实现，所以获取到的是null。
Application ClassLoader（应用加载器）
被称为系统（也称为应用）类加载器，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性，或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现，父类加载器为ExtClassLoader。
Custom ClassLoader（自定义类加载器）
用户自定义的继承了ClassLoader的类，只要是自定义classLoader 必须继承ClassLoader， 同时类加载器的父子类关系不是JAVA中的继承关系，而是一种逻辑父类关系
源码验证
//父子类加载器 验证
public class ClassLoaderTest {
public static void main(String[] args) {
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println("main classLoadee: " + classLoader);
System.out.println("ext classLoadee: " + classLoader.getParent());
System.out.println("bootstrap classLoadee: " + classLoader.getParent().getParent());
}
}
//result----------------------------------
main classLoadee: sun.misc.Launcher$AppClassLoader@18b4aac2
ext classLoadee: sun.misc.Launcher$ExtClassLoader@1be6f5c3
bootstrap classLoadee: null//类加载器的父子关系是逻辑父子不是继承
public abstract class ClassLoader {
//类加载器父类属性
private final ClassLoader parent;
//构造器
protected ClassLoader() {
this(checkCreateClassLoader(), getSystemClassLoader());
}
protected ClassLoader(ClassLoader parent) {
this(checkCreateClassLoader(), parent);
}
private ClassLoader(Void unused, ClassLoader parent) {
this.parent = parent;
if (ParallelLoaders.isRegistered(this.getClass())) {
parallelLockMap = new ConcurrentHashMap<>();
package2certs = new ConcurrentHashMap<>();
assertionLock = new Object();
} else {
// no finer-grained lock; lock on the classloader instance
parallelLockMap = null;
package2certs = new Hashtable<>();
assertionLock = this;
}
}
//获取父类加载器
public final ClassLoader getParent() {
if (parent == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// Check access to the parent class loader
// If the caller's class loader is same as this class loader,
// permission check is performed.
checkClassLoaderPermission(parent, Reflection.getCallerClass());
}
return parent;
}
}类加载
类加载分为三步
加载-》连接-》初始化
连接包含三部分
验证-》准备-》解析
简单概括为 家宴准备了西式菜 (加载 验证 准备 解析 初始化)
1.加载
加载指的是将类的class文件读入到内存，并为之创建一个java.lang.Class对象
2.链接
类连接又可分为如下3个阶段。
1)验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致。其主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。
四种验证做进一步说明：
文件格式验证：主要验证字节流是否符合Class文件格式规范，并且能被当前的虚拟机加载处理。例如：主，次版本号是否在当前虚拟机处理的范围之内。常量池中是否有不被支持的常量类型。指向常量的中的索引值是否存在不存在的常量或不符合类型的常量。
元数据验证：对字节码描述的信息进行语义的分析，分析是否符合java的语言语法的规范。
字节码验证：最重要的验证环节，分析数据流和控制，确定语义是合法的，符合逻辑的。主要的针对元数据验证后对方法体的验证。保证类方法在运行时不会有危害出现。
符号引用验证：主要是针对符号引用转换为直接引用的时候，是会延伸到第三解析阶段，主要去确定访问类型等涉及到引用的情况，主要是要保证引用一定会被访问到，不会出现类等无法访问的问题。
2)准备：类准备阶段负责为类的静态变量分配内存，并设置默认初始值。
3)解析：将类的二进制数据中的符号引用替换成直接引用。个人理解：符号引用就是定义的变量名，直接引用就是在内存中的地址
3.初始化
初始化是为类的静态变量赋予正确的初始值，准备阶段只是分配内存，赋默认值
4.类加载时机
- 创建类的实例，也就是new一个对象
- 访问某个类或接口的静态变量，或者对该静态变量赋值
- 调用类的静态方法
- 反射（Class.forName("com.lyj.load")）
- 初始化一个类的子类（会首先初始化子类的父类）
- JVM启动时标明的启动类，即文件名和类名相同的那个类
除此之外，下面几种情形需要特别指出：
对于一个final类型的静态变量，如果该变量的值在编译时就可以确定下来，那么这个变量相当于“宏变量”。Java编译器会在编译时直接把这个变量出现的地方替换成它的值，因此即使程序使用该静态变量，也不会导致该类的初始化。反之，如果final类型的静态Field的值不能在编译时确定下来，则必须等到运行时才可以确定该变量的值，如果通过该类来访问它的静态变量，则会导致该类被初始化。
双亲委派
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
//双亲委派机制
//如果想要打破双亲委派 可以重写loadClass
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
//防止并发加载，一个类只需要被一个classloader加载一次
synchronized (getClassLoadingLock(name)) {
//先判断是否已经被改类加载器加载过
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
//如果父类加载器不是null，即不是bootstrap 类加载器，通过父类加载器加载
if (parent != null) {
c = parent.loadClass(name, false);
} else {
//调用bootstrap 类加载器加载
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
//如果父类加载器没有加载过或加载不到，就通过自己加载
if (c == null) {
long t1 = System.nanoTime();
//自定义的类加载器需要重写findClass方法 默认该方法抛出异常
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}自定义类加载器
- 继承ClassLoader
- 如果需要打破双亲委派重写loadClass
- 重写findClass，class的加解密，网络加载都可以在该方法实现，ClassNotFoundException需要自己处理
- 可以根据需求设置父类加载器
六 SPI
SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。
文件名是接口全路径名
内容是实现类全类名，多个实现类用换行
通过ServiceLoader获取
ServiceLoader<CustomService> load = ServiceLoader.load(CustomService.class);
Iterator<CustomService> iterator = load.iterator();
while(iterator.hasNext()) {
CustomService cs = iterator.next();
}public final class ServiceLoader<S>
implements Iterable<S>
{
//寻找SPI的目录
private static final String PREFIX = "META-INF/services/";
//构造器 传入接口名
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
//主要是reload方法， ClassLoader 一般为当前线程的类加载器
private ServiceLoader(Class<S> svc, ClassLoader cl) {
service = svc;
loader = cl;
reload();
}
public void reload() {
providers.clear();
//真正用于加载类的服务
lookupIterator = new LazyIterator(service, loader);
}
//调用lookupIterator
public Iterator<S> iterator() {
return new Iterator<S>() {
Iterator<Map.Entry<String,S>> knownProviders
= providers.entrySet().iterator();
public boolean hasNext() {
return lookupIterator.hasNext();
}
public S next() {
return lookupIterator.next();
}
};
}
private class LazyIterator
implements Iterator<S>
{
public boolean hasNext() {
if (configs == null) {
try {
//所以文件名是META-INF/services/ + 全类名
String fullName = PREFIX + service.getName();
if (loader == null)
configs = ClassLoader.getSystemResources(fullName);
else
configs = loader.getResources(fullName);
} catch (IOException x) {
}
}
return true;
}
public S next() {
try {
//通过Class.forName所以实现类要写全类名
c = Class.forName(cn, false, loader);
} catch (ClassNotFoundException x) {
}
try {
//反射生成对象
S p = service.cast(c.newInstance());
providers.put(cn, p);
return p;
} catch (Throwable x) {
}
}
}
}JDBC的核心接口通过Bootstrap加载器加载，但是实现类是不同厂商实现，由应用类加器加载，是在编译时才确定的
不同类加载器加载的类是逻辑隔离的
通过SPI就可以变相的打破双亲委派，获取不同的实现类
Spring SPI ：通过SpringFactoriesLoader 加载META-INF/spring.factories文件内容是key=value。key可以是接口，也可以是抽象类、具体的类，注解。value必须是key的实现类必须不是抽象类，必须能够实例化。且有空的构造函数，多个key-value换行分割，多个实现类 , 分隔
Dubbo SPI ：通过 ExtensionLoader 加载META-INF/dubbo/接口全类名文件内容是key=value。key是别名，value是实现类全类名，换行分割。
dubbo的扩展机制设计默认值：@SPI(“dubbo”) 代表默认的spi对象
Dubbo的扩展机制支持IoC,AoP等高级功能
1226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
