Java进阶知识点总结

JAVA进阶知识学习目录章法章8码章程章O章式章架章库章法 章a机章具章b关二x章关章ML章jk性章式第一章基本语法（一）关键字1、static修饰变量、方法、静态块、静态内部内、静态导包。。2\h、\hfinal1.final修饰的部分类、方法、域、方法参数2作用a.设计上：被final修饰的类不能被继承；被final方写被final修饰的变量的引用不能被修改。b.被finalinline在a编做种优化操作）会起作用。字“”。3为什么Java匿名内部类访问的外部局部变量或参数需要被final修饰？内部类对象的生命周期会超过局部变量的生命期。建：它，但该局部类的对象仍然活着。即：局部类的对象生命期会超过局部变量。3、transient用rt关键字标记的成员变量不参与序列化过程。14\h、\hvolatile用成volatilea量。j5）比d调。e是基于MyBarir实现的。如果一个变量是ve修饰的，JM会在写入这个字段之后插进一个Wrr指令，并在读这个字段之前插入一个Re-arer指令。Wa在Barrr之前写入cache因此，任何CU上的线程都能读取到这些数据的最新版本。底层基于的ve实现，因为volatile自带了编译器屏障的功能，总能拿到内存中的最新值。e修饰的变量进行写操作的时候会多了一行下面的汇编代码。k前缀指令的作用有两个：1.将当前处理器缓存行的数据会写回到系统内存。2.这个写回内存的操作会引起在其他CU里缓存了该内存地址的数据无效。备注：测试代码cclssazSingleton{prvesatcvoltileazSngletoninstce=nll;cstticLazSngletoneIstance(){fistance==nul){inte=wLazSingleton();}nintance;}cstticdmai(String[]rgs){LaySinleton.getnane();}}通过s查看汇编代码2java-XX:+UnlockDiagnosticVMOptions-XX:+PrintAssembly-XX:FreqInlineSize=1-XX:MaxInlineSize=1-XX:CompileThreshold=1-Xcomp-XX:CompileCommand=dontinline,*LazySingleton.getInstance-XX:CompileCommand=compileonly,*LazySingleton.getInstance-XX:LogFile=jit.logLazySingletonlockaddl$0x0,(%rsp)5、synchronizedSynchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。从语法上讲，Synchronized总共有三种用法：（1）修饰普通方法（2）修饰静态方法（3）修饰代码块3原理monitor对象monitor的所有权。在线程进入时通过monitorenter尝试取得对象monitor所有权，退出时通过monitorexit释放对象monitor所有权。monitorenter线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：1果monitor的进入数为0入monitor置为1，该线程即为monitor的所有者。2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1。3.如果其他线程已经占用了monitor到monitor的进入数为0，再重新尝试获取monitor的所有权。monitorexit执行monitorexit的线程必须是objectref所对应的monitor的所有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor线以尝试去获取这个monitor的所有权。同步代码块使用了monitorenter和monitorexit指令实现。同步方法中依靠方法修饰符上的ACC_SYNCHRONIZED实现。种上对的monitor程阻塞，并放入到同步队列中，进入BLOCKED状态。1．修饰块cclsslokTest{cvoidsy){tlock=wObect();sycrnzlok){Sytmut.printl();}}}JavacTest.javajavap-l-vTest.class42.修饰方法cclssethodTest{csychronizedvoidsy){Sytmut.printl("HeloWord");}}当方法调用时，调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否设，果设了执行程先取monitor，取功后才执方法，法行完再放monitor。方执期间其任何程无再获得同一个monitor对象。其实本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。锁升级是单向的:无锁->偏向锁->轻量级锁->重量级锁56、importJava编译器默认为所有的Java程序导入了JDK的java.lang包中所有的类（importjava.lang.*;。但是使用其他类必须先导入。在编译器进行编译时，每个名字都会经过解析找到其全名。7、enumcenumnmTest{CNEE,SIG,CODITIN,PROAGATE}6在使用关键字enum创建枚举类型并编译后，编译器会为我们生成一个相关的类，这个类继承了java.lang.Enum。特征：1.不能有public的构造函数；2.所有的枚举变量都是publicstaticfinal的；3.默认实现了java.lang.Comparable接口；优点：1.可以进行类型检测。2.用enum关键字声明的常量由编译程序自动生成。3.用enum关键字声明常量使程序更清晰易读。缺点：每一个枚举值都是一个对象,在使用它时会增加额外的内存消耗。应用：错误码、单例模式、状态机（二）foreach通过查看对应的字节码可知，foreah语法最终被编译器转为了对Itrto.aex(和对Irto.ex()的调用。7（三）Serializable1、实现序列化的步骤Filefile=newFile("E:/Serializable.txt");ObjectOutputStreamout=newObjectOutputStream(newFileOutputStream(file));out.writeObject(object);out.close();ObjectInputStreamin=newObjectInputStream(newFileInputStream(file));ObjectnewPerson=in.readObject();in.close();System.out.println(newPerson);82、为什么一个类实现了Serializable列化呢？privatevoidwriteObject0(Objectobj,booleanunshared)throwsIOException{......if(objinstanceofString){writeString((String)obj,unshared);}elseif(cl.isArray()){writeArray(obj,desc,unshared);}elseif(objinstanceofEnum){writeEnum((Enum<?>)obj,desc,unshared);}elseif(objinstanceofSerializable){writeOrdinaryObject(obj,desc,unshared);}else{if(extendedDebugInfo){thrownewNotSerializableException(cl.getName()+"\n"+debugInfoStack.toString());}else{thrownewNotSerializableException(cl.getName());}}......}3、默认序列化机制如果仅仅只是让某个类实现Serializable则就是使用默认序列化机制。对象引用的其它对象也进行序列化。4、SerialVersionUID的作用如果不手动指定给SerialVersionUID系前的hash赋予给serialVeionUID,个serialersionUID就会不一致，导致反序列化失败。95、影响序列化1）transient关键字当某个字段被声明为transient后，默认序列化机制就会忽略该字段。static、tranient修饰的字段不会被序列化。2）writeObject()方法与readObject()法3）Externalizable口publicinterfaceExternalizableextendsjava.io.Serializable{voidwriteExternal(ObjectOutputout)throwsIOException;voidreadExternal(ObjectInputin)throwsIOException,ClassNotFoundException;}K中提供了另一个序列化接口--Externalizable。若使用Externalizable参象中。4）readResolve()为了能在序列化过程仍能保持单例的特性，可以在类中添加一个readResolve()方法，在该方法中直接返回类的单例对象。总结：无论是实现Serializable是Extrlale从I/O对象时，readResolve()方法都会被调用到。实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象，而被创建的对象则会被垃圾回收掉。106、常见第三方库？）Gson）fastjson（四）注解的原理1、注解的类型1.java自带的标准注解2元注解（用于定义注解的注解）3自定义注解2、原理注解被编译后的本质就是一个继承Annotation接口的接口，所以t其实就是“publicinterfacetextendsAnnotation”，当我们通过AnnotationTes.lass.getAnotationTest.class)调用时，K会通过动态代理生成一个实现了t接口的对象，并把将RuntimeVisibleAnnotations属性值设置进此对象中，此对象即为t注解对象，通过它的value()方法就可以获取到注解值。11第二章JDK8源码（一）UnsfeJaat还是包含了一个后门unmcUa，提供了一些可以直接操控内存和线程的底层操作。Use被JDK广泛应用于jo一个观察tJVM内部结构并且可以对其进行修改，但是不建议在生产环境中使用。1、Unsafe的限制1.私有的构造器2.工厂方法ge的调用器只能被r加载，否则抛出Sn异常2、API1.t获取指定实例变量在对象内存中的偏移量。longoffset=UNSAFE.objectFieldOffset(Test.class.getDeclaredField("state"));2.cmanant通过比较并替换的机制，修改指定偏移量内存的值。UNSAFE.compareAndSwapInt(unsafeTest,offset,0,1)3pa：阻塞当前线程。4unpr：唤醒某一（已被阻塞的）线程5mntoEn：Lkthetm：ket123、获取UnsafepublicfinalclassUnsafeUtils{privateUnsafeUtils(){}privatestaticclassUnsafeHolder{privatestaticfinalUnsafeunsafe=AccessController.doPrivileged(newPrivilegedAction<Unsafe>(){publicUnsaferun(){try{Fieldunsafe=Unsafe.class.getDeclaredField("theUnsafe");unsafe.setAccessible(true);return(Unsafe)unsafe.get(null);}catch(NoSuchFieldExceptione){thrownewIllegalStateException(e);}catch(IllegalAccessExceptione){thrownewIllegalStateException(e);}}});}publicstaticUnsafegetUnsafe(){returnUnsafeHolder.unsafe;}}13（二）j.lang1、ShortpublicfinalclassShortextendsNumberimplementsComparable<Short>{publicstaticfinalshortMIN_VALUE=-32768;publicstaticfinalshortMAX_VALUE=32767;publicstaticfinalClass<Short>TYPE=(Class<Short>)Class.getPrimitiveClass("short");privatefinalshortvalue;publicstaticfinalintSIZE=16;publicstaticfinalintBYTES=SIZE/Byte.SIZE;privatestaticclassShortCache{privateShortCache(){}staticfinalShortcache[]=newShort[-(-128)+127+1];static{for(inti=0;i<cache.length;i++)cache[i]=newShort((short)(i-128));}}publicstaticShortvalueOf(shorts){finalintoffset=128;intsAsInt=s;if(sAsInt>=-128&&sAsInt<=127){returnShortCache.cache[sAsInt+offset];}returnnewShort(s);}......}2字节长度，6位。方法实现基于Integer。缓存了[,1之间的值。142、IntegerpublicfinalclassIntegerextendsNumberimplementsComparable<Integer>{@NativepublicstaticfinalintMIN_VALUE=0x80000000;@NativepublicstaticfinalintMAX_VALUE=0x7fffffff;publicstaticfinalClass<Integer>TYPE=(Class<Integer>)Class.getPrimitiveClass("int");finalstaticchar[]digits={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};privatefinalintvalue;privatestaticclassIntegerCache{staticfinalintlow=-128;staticfinalinthigh;staticfinalIntegercache[];static{inth=127;StringintegerCacheHighPropValue=sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");if(integerCacheHighPropValue!=null){try{inti=parseInt(integerCacheHighPropValue);i=Math.max(i,127);h=Math.min(i,Integer.MAX_VALUE-(-low)-1);}catch(NumberFormatExceptionnfe){}}high=h;cache=newInteger[(high-low)+1];intj=low;for(intk=0;k<cache.length;k++)cache[k]=newInteger(j++);assertIntegerCache.high>=127;}privateIntegerCache(){}}publicstaticIntegervalueOf(inti){if(i>=IntegerCache.low&&i<=IntegerCache.high)returnIntegerCache.cache[i+(-IntegerCache.low)];returnnewInteger(i);}......}4字节长度，2,high]之间的值，high默认1配不小于12。153、DoublecfiallasDoubeextnsNumrmpementsComarable<Duble>{cstticfinlintSIZE=;cstticfinlintBTES=IZE/Byt.SIZE;cstticfinlCas<Double>E=(lass<ouble>)ClsePrimitivClass"ouble";privatefnldoubevalue;.}8字节长度，4位。4、FloatcfiallasFloatextendsNumberimlemetsCopaable<Flat>{cstticfinlintSIZE=;cstticfinlintBTES=IZE/Byt.SIZE;cstticfinlCas<Float>TYPE=Cass<Floa>)ClsePrimitivClass"float";privatefnlfloataue;.}4字节长度，2位。165、LongcfiallasLongextendsNmerimpemensoparable<ong>{prvefnlgvalue;aivecstticfinlintSIZE=;cstticfinlintBTES=IZE/Byt.SIZE;cstticfinlClass<Long>TYPE=(Cass<Long)ClsePrimitivClass"long";prvesaicclasLngCace{prveLongCache(){}cfialLongcace]=newLog[-(128)+7+1];c{rinti=0;i<cce.leg;)[]=wLong(i-18);}}cstticgvaleOf(long){ltofst=128;fl=-128&l=){nLongCace.cachent)l+offset;}nwLong();}.}8字节长度，4位。缓存了,1]之间的值。176、CharactercfiallasCharactrmplementsjaa.ioSerializable,Copbeaatr>{prvefnlrvalue;cstticfinlintSIZE=;cstticfinlintBTES=IZE/Byt.SIZE;cstticfinlCas<Character>TYPE=(Class<haracter>)ClsePrimitivClass"char";prvesaicclasCharacterCache{prveCaacterCache(){}cfialCaractrcache]=newCaractr[127+1];c{rinti=0;i<cce.leg;)[]=wChaacter((chr));}}cstticChaacteraleOf(charc){fc=127){reunCharactrCache.caheint];}reunwCharactr(c;}.}2字节长度，6位。缓存了ASCII码表中的字符。7、BooleancfiallasBoolnimlementsjaa.elzbe,Coparale<Boolean>{cstticfinlBooleanTRUE=wBooean(true;cstticfinlBooleanFLE=newBoean(fase;cstticfinlCas<Boolean>TYPE=(lass<oolen>)ClsePrimitivClass"oolean");prvefnlboolnvalue;.}188、BytepublicfinalclassByteextendsNumberimplementsComparable<Byte>{publicstaticfinalbytepublicstaticfinalbyte

MIN_VALUE=-128;MAX_VALUE=127;publicstaticfinalintSIZE=8;publicstaticfinalintBYTES=SIZE/Byte.SIZE;privatefinalbytevalue;publicstaticfinalClass<Byte> TYPE=(Class<Byte>)Class.getPrimitiveClass("byte");privatestaticclassByteCache{privateByteCache(){}staticfinalBytecache[]=newByte[-(-128)+127+1];static{for(inti=0;i<cache.length;i++)cache[i]=newByte((byte)(i-128));}}publicstaticBytevalueOf(byteb){finalintoffset=128;returnByteCache.cache[(int)b+offset];}......}1字节长度，8位。缓存了所有的值，[,12]之间对应的byte。9、StringpublicfinalclassStringimplementsjava.io.Serializable,Comparable<String>,CharSequence{privatefinalcharvalue[];publicStringconcat(Stringstr){intotherLen=str.length();if(otherLen==0){returnthis;}intlen=value.length;charbuf[]=Arrays.copyOf(value,len+otherLen);str.getChars(buf,len);returnnewString(buf,true);}......}特征：1底层基于char[实现，且被final修饰。2+是new了一个StringBuilder过d方法连接，最后toString。1910、StringBufferpublicfinalclassStringBufferextendsAbstractStringBuilderimplementsjava.io.Serializable,CharSequence{privatetransientchar[]toStringCache;publicStringBuffer(){super(16);}@OverridepublicsynchronizedStringBufferappend(Stringstr){toStringCache=null;super.append(str);returnthis;}@OverridepublicsynchronizedStringtoString(){if(toStringCache==null){toStringCache=Arrays.copyOfRange(value,0,count);}returnnewString(toStringCache,true);}......}abstractclassAbstractStringBuilderimplementsAppendable,CharSequence{char[]value;intcount;voidexpandCapacity(intminimumCapacity){intnewCapacity=value.length*2+2;if(newCapacity-minimumCapacity<0)newCapacity=minimumCapacity;if(newCapacity<0){if(minimumCapacity<0)thrownewOutOfMemoryError();newCapacity=Integer.MAX_VALUE;}value=Arrays.copyOf(value,newCapacity);}publicAbstractStringBuilderappend(Stringstr){if(str==null)returnappendNull();intlen=str.length();ensureCapacityInternal(count+len);str.getChars(0,len,value,count);count+=len;returnthis;}......}特征：1底层基于char[]实现，没有final修饰，初始容量为，每次扩容为原20来的2n+2。2线程安全的，大多数方法有synchronized修饰。3.toString()方法缓存了char[。11、StringBuilderpublicfinalclassStringBuilderextendsAbstractStringBuilderimplementsjava.io.Serializable,CharSequence{publicStringBuilder(){super(16);}@OverridepublicStringBuilderappend(Stringstr){super.append(str);returnthis;}@OverridepublicStringtoString(){//Createacopy,don'tsharethearrayreturnnewString(value,0,count);}......}特征：1底层基于char[实现，初始容量为1，每次扩容为原来的2n+2。2是线程不安全的。3.toString()方法每次重新new了一个char[。2112、ThreadpublicclassThreadimplementsRunnable{privatevolatilecharname[];privateintpriority;privateRunnabletarget;ThreadLocal.ThreadLocalMapthreadLocals=null;ThreadLocal.ThreadLocalMapinheritableThreadLocals=null;privatelongtid;privatevolatileintthreadStatus=0;publicfinalstaticintMIN_PRIORITY=1;publicfinalstaticintNORM_PRIORITY=5;publicfinalstaticintMAX_PRIORITY=10;privatevolatileInterruptibleblocker;privatefinalObjectblockerLock=newObject();publicenumState{NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;}privatevoidinit(ThreadGroupg,Runnabletarget,Stringname,longstackSize,AccessControlContextacc){......this.group=g;this.daemon=parent.isDaemon();this.priority=parent.getPriority();if(security==null||isCCLOverridden(parent.getClass()))this.contextClassLoader=parent.getContextClassLoader();elsethis.contextClassLoader=parent.contextClassLoader;this.inheritedAccessControlContext=acc!=null?acc:AccessController.getContext();this.target=target;setPriority(priority);if(parent.inheritableThreadLocals!=null)this.inheritableThreadLocals=ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);this.stackSize=stackSize;tid=nextThreadID();}publicsynchronizedvoidstart(){......}publicstaticnativebooleanholdsLock(Objectobj);......}22特征：1线程有6种状态。2每线都一个先，高先线的执优于低先线。设置的优先级不会高于线程组的最大优先级。3每线都以设成个守线（能在动前设，能启动。4当新建一个Thread，如果创建线程是守护线程，那么新线程也是守护线程。线程状态：NEW：初始状态，线程被创建，但是还没有调用start()。RUNNABLEJava线将作统中就和运两状笼统地称作运行中。BLOCKED：阻塞状态，等待持有锁。WAITING些。TIMED_WAITING：超时等待状态。TERMINATED：终止状态。方法：start()：线程启动方法。join()：堵塞主线程，使其处于等待状态，直到子线程死掉。sleep()：睡眠指定毫秒，并不释放monitor。23yeild()：使当前线程从运行状态变为就绪状态。cpu会从众多的可执行态里并不是说一定会执行其他线程而该线程在下一次中不会执行到了。suspend()：将一个线程挂起(暂停)，过时。它不会释放锁。resume()：将一个挂起线程复活继续执行，过时。interrupt()中断设置线程的中断状态位，不会停止线程。interrupted()为true。isInterrupted()。作用于调用该方法的线程对象所对应的线程。holdsLock(obj)：判断当前线程是否拥有对象的监视器。注意：1.wi方法会释放CPU执行权和占有的锁。2.sleep(long)方法仅释放CPU使权锁然占；程被入时待队列，与yield相比，它会使线程较长时间得不到运行。3.yield(方法仅释放CPU执权锁然占，程会放就队列会在短时间内再次执行。wait和notify必配使，即须用同把调。.Thread.suspend和haeme成。2413、ThreadLocal（线程局部变量）cclsshreadLocal<T>{privatefnltthradLocalHshCode=netHshCode();privatesaicAtoicIntegernxHashCode=wAtmicIteger();privatesaicfinlintHAH_INREMENT=0x61c88647;pulcTgt){Thedt=Thread.curentThread;TheadLcalMapp=getMap();fmap=null){TheadLcalMap.Etrye=map.gtEntry(this);fe=nll){Tresut=(T)vau;reunresu;}}reunseIntialValue();}privateTsetInitalValue(){Tvale=intialVlue();Thedt=Thread.curentThread;TheadLcalMapp=getMap();fmap=null)map.st(this,value;elsecreateMap(,value;reunvaue;}....}25cclsshreadLocalMap{sttcclssntyextnsWekRefeence<Threadocal<?>>{Obetvaue;Enry(TreadLocal<?>k,bjct){suer(;vaue=;}}privatesaicfinlintINTIALCAPACITY=;privateEntry[]ale;privateinttrshold;/Defuto0privatevoidsetThreshold(t){theshod=len*2/;}privateEtygetntry(Threadocal<?>key){inti=keyheadLocalashCode&taleenth-1);Enrye=table];fe=null&e.ge()==key)reun;elsereungetEntrAfterMiss(key,,);}privatevoidrhash(){exungetaleEntries(;f(sie>=thrshold-heshold/)reize(;}privatevoidrsize(){Entry[]odTb=table;intodLn=ldTablength;intnwLn=oldLen*;Entry[]nwTb=newntry[neL];intcunt=;forintj=0;j<ldLen;++){Enrye=oldTj;fe=nll){TheadLcal<?>k=get();f(k=nll){.value=null;}e{inth=.threadLcalHashCde&nwen-1);whleeTb[]!=nll)h=nextIndex(,newLen;newTab]=;cont++;}}}seThrehold(newLen;size=cont;tale=newTab;}....}26cclssThreadmlemetsRunnable{TheadLcal.ThreadLoalMaptheaocls=null;TheadLcal.ThreadLoalMapineritablehreadLocls=null;....}而ThreadLocal是保证了多线程环境下数据的独立性。在每个Thread里面都维护着一个ThradLocal.TreadLocalMap集合（即在不同的Thread。ThedLocal（线程局部变量）实现机制：1每个线程中都有一个独立的ThreadLocalMap被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中实现隔离。2当调用get()方法的时候，先获取当前线程，然后获取到当前线程的ThreadLocalMap如么出haLclp的value行初始化，初始化就是将initialValue的值set到TheLaap中。特征：1底层基于Entry[]实现，Entryy为ThradLoca用队列里；value为真正需要存储的Object。2为2的次方）16子0.（2/3)*(3/4)为原理的2倍。3采用开放定址法解决hash冲突。hashcode的生成：hashcode从0开始不断累加HASH_INCREMENT（其目：为了让hashce27能更好地分布在尺寸为2的N。ThedLocal导致的内存泄露：ThreadLocalMap使用ThradLocal的弱引用作为，如果一个l么GC个y果value存在强引用的话，Entry还是不能被回收。解决办法：调用ThreadLocal的get、set()、rem。ThedLocal优点：．节约资源．线程安全14、InheritableThreadLocalcclssnhritableThreadLocl<T>extesTheadLocalT>使用InheritableThreadLocal可以将某个线程的ThreadLocal创建时传递过去。原理：2815、ObjectpublicclassObject{publicfinalnativeClass<?>getClass();publicnativeinthashCode();publicbooleanequals(Objectobj){return(this==obj);}protectednativeObjectclone()throwsCloneNotSupportedException;publicStringtoString(){returngetClass().getName()+"@"+Integer.toHexString(hashCode());}publicfinalnativevoidnotify();publicfinalnativevoidnotifyAll();publicfinalnativevoidwait(longtimeout)throwsInterruptedException;publicfinalvoidwait(longtimeout,intnanos)throwsInterruptedException{if(timeout<0){thrownewIllegalArgumentException("timeoutvalueisnegative");}if(nanos<0||nanos>999999){thrownewIllegalArgumentException("nanosecondtimeoutvalueoutofrange");}if(nanos>0){timeout++;}wait(timeout);}publicfinalvoidwait()throwsInterruptedException{wait(0);}protectedvoidfinalize()throwsThrowable{}}方法：hashCode()：认况，对的希码通将对象内地址换成一个整数来实现的。equals：比较两个对象是否相等（比较2。toString()：对象的名字@hashCode的16进制。notify()：final修饰。唤醒一个在此对象监视器上等待的线程。wait()final获得执行权，并持有了相同的监视器（锁）并调用notify为止。finalize()：当M进行垃圾回收时触发。wait为什么被建议放在一个while循环里？29wait好先获取到了监视器，从而导致状态发生了变化，这时候用while循环来再判断一下条件（比如队列是否为空）来避免不必要或有问题的操作。这种机制还可以用来处理伪唤醒（spuriouswakeup是noreasonwakeup。自旋的好处是线程不需要睡眠和唤醒，减小了系统调用的开销。wait/notify与monitor关系：．ait调用之前，必须获取到monitor；．调用wait后，会释放掉monitor；．调用notify之前，必须获取到monitor；．调用notify后要手动释放掉monitor；．当wait被唤醒后，会自动获取monitor。．如果主线程终止（执行完成）了，也会释放掉monitor。hashCode()返回值与eua()关系：．equals()相等，那么hashCode()一定是相等的；．hashCode()相等，equals()不一定相等。因此，改写equals()时，总是要改写hashCode()。关于filize(：尽管finalize，基于以下几点：．不保证会被jvm执行，且不知道何时才会执行。这就给程序执行带来了很大不确定性。．不同的jvm垃圾回收算法不一致，在一个jvm上作好可能另一个jvm上未必有效。据JoshualochEiveJv了e，对象的创建和销毁时间慢了0倍。在什么情况下会重写haCd和equ(?的equals1==object2上的相等，而是一种业务上的对象相等。（三）java.lang.ref（//TODO:）对象的有效性可达性引用类型301、ReferenceQueuepublicclassReferenceQueue<T>{privatevolatileReference<?extendsT>head=null;......}存放引用的队列，保存的是Rerence对象。其作用在于Refrence对象所引用的对象被GC回收时，该Rerence对象将会被加入引用队列中（Refncu）的队列末尾。2、Reference引用对象的抽象基类，这个类中定义了所有引用对象的常用操作。313、PlantomReference（虚引用）reeuu踪垃的fe方法，在使用虚引用可以实现该动作，也更加安全。4、SoftReference（软引用）不出M。5、WeakReference（弱引用）管内存是否足够，只要被垃圾收集器发现，该引用的对象就会被回收。326、FinalReference（强引用）有强引用，GC绝不会回收它，当内存空间不足时，JVM宁愿抛出。nw出来的对象是典型的强引用。7、Finalizer（四）java.util1、ArrayListpublicclassArrayList<E>extendsAbstractList<E>implementsList<E>,RandomAccess,Cloneable,java.io.Serializable{privatestaticfinalintDEFAULT_CAPACITY=10;transientObject[]elementData;......}33Arryt大小为10加50%用Sa()复制到新的数组。a：1.调用epcl储的数量大于数组的长度，则扩容为原来的1.5倍；旧数据赋值通过Sy实现。2.将数据放在数组中。get：检查x范围，如果超出范围，抛异常；否则，返回数据。remove：检查x过Ssearaoy将(in+1后面的数据往前移一位；并将删除的对象的引用标记为。和LinkedList的区别A1、ryit了组，t基于链表的数据结构。A，2问t和stAryit优于为LinkedList要移动指针。，343作d和inkedList比较占优势，因为Aayit要移动数据。和Vector的区别1、er和AryLt几乎是完全相同的唯一的区别在于r是同步类(ynhon，属于强同步类。因此开销就比rat要大，访问要慢。2、er每次扩容请求其大小的2倍空间，而AryLt是1.5倍。3、er还有一个子类S.2、LinkedListpublicclassLinkedList<E>extendsAbstractSequentialList<E>implementsList<E>,Deque<E>,Cloneable,java.io.SerializableprivatestaticclassNode<E>{Eitem;Node<E>next;Node<E>prev;......}t以双向链表实现。get：检查x果index<size/2，则从链表头开始遍历；否则从链表尾开始遍历。353、ectorpublicclassVector<E>extendsAbstractList<E>implementsList<E>,RandomAccess,Cloneable,java.io.Serializable特征：1.初始容量为10；扩容是时，新增为原来的两倍。2.方法加了synchronized。4、StackpublicclassStack<E>extendsVector<E>特征：it(LIFO)2.方法加了synchronized。5、rrayDequepublicclassArrayDeque<E>extendsAbstractCollection<E>implementsDeque<E>,Cloneable,Serializable{transientObject[]elements;transientinthead;transientinttail;//Mustbeapowerof2.privatestaticfinalintMIN_INITIAL_CAPACITY=8;......publicintsize(){return(tail-head)&(elements.length-1);}}36head指向首端第一个有效元素，tail指尾第个可插元素空。因为是循环数组，所以head不一定总等于0，tail也不一定总是比head大。特征：ArrayDeue采用了循环数组的方式来完成双端队列的功能。用两个t的h、l分别表示队列的头部下标、尾部下标。循环是通过表达式(tail=37(tail+1)&(elements.length-1))实现的。1.数组的容量为2增1证2的次方，见hap部分）2.非线程安全的，不支持并发访问和修改。3.支持fa。4.作为栈使用的话比栈要快。5.当队列使用比t要快。6.nl元素被禁止使用。6、HashSetpublicclassHashSet<E>extendsAbstractSet<E>implementsSet<E>,Cloneable,java.io.Serializable{privatetransientHashMap<E,Object>map;privatestaticfinalObjectPRESENT=newObject();publicHashSet(){map=newHashMap<>();}publicHashSet(Collection<?extendsE>c){map=newHashMap<>(Math.max((int)(c.size()/.75f)+1,16));addAll(c);}publicHashSet(intinitialCapacity,floatloadFactor){map=newHashMap<>(initialCapacity,loadFactor);}publicHashSet(intinitialCapacity){map=newHashMap<>(initialCapacity);}HashSet(intinitialCapacity,floatloadFactor,booleandummy){map=newLinkedHashMap<>(initialCapacity,loadFactor);}publicbooleanadd(Ee){returnmap.put(e,PRESENT)==null;}}Hahet底层用Hahap实现；Haht的vae用map的Ky存储，map的ae用一个虚拟的staticfinal修饰的t代替；是对HashMap的简单包装，对Haht的函数调用都会转换成合适的Hahap方法。387、itSetpublicclassBitSetimplementsCloneable,java.io.Serializable{privatefinalstaticintADDRESS_BITS_PER_WORD=6;privatefinalstaticintBITS_PER_WORD=1<<ADDRESS_BITS_PER_WORD;privatefinalstaticintBIT_INDEX_MASK=BITS_PER_WORD-1;privatelong[]words;privatevoidensureCapacity(intwordsRequired){if(words.length<wordsRequired){intrequest=Math.max(2*words.length,wordsRequired);words=Arrays.copyOf(words,request);sizeIsSticky=false;}}publicvoidset(intbitIndex){if(bitIndex<0)thrownewIndexOutOfBoundsException("bitIndex<0:"+bitIndex);intwordIndex=wordIndex(bitIndex);expandTo(wordIndex);words[wordIndex]|=(1L<<bitIndex);checkInvariants();}......}个lo[]占4的2。398、reeSetpublicclassTreeSet<E>extendsAbstractSet<E>implementsNavigableSet<E>,Cloneable,java.io.Serializable{privatetransientNavigableMap<E,Object>m;privatestaticfinalObjectPRESENT=newObject();publicTreeSet(){this(newTreeMap<E,Object>());}publicbooleanadd(Ee){returnmap.put(e,PRESENT)==null;}......}t底层用Tp实现；Treet的value用map的Key存储，map的ae用一个虚拟的staticfinal修饰的t代替；是对TreeMap的简单包装，对et的函数调用都会转换成合适的p方法。9、LinkedHashSetpublicclassLinkedHashSet<E>extendsHashSet<E>implementsSet<E>,Cloneable,java.io.Serializableaht是对Lep对Haht的函数调用都会转换成合适的Hahap方法。4010、HashMappublicclassHashMap<K,V>extendsAbstractMap<K,V>implementsMap<K,V>,Cloneable,Serializable{staticfinalintDEFAULT_INITIAL_CAPACITY=1<<4;staticfinalintMAXIMUM_CAPACITY=1<<30;staticfinalfloatDEFAULT_LOAD_FACTOR=0.75f;staticfinalintTREEIFY_THRESHOLD=8;staticfinalintUNTREEIFY_THRESHOLD=6;staticfinalintMIN_TREEIFY_CAPACITY=64;staticclassNode<K,V>implementsMap.Entry<K,V>{finalinthash;finalKkey;Vvalue;Node<K,V>next;......}staticfinalclassTreeNode<K,V>extendsLinkedHashMap.Entry<K,V>{TreeNode<K,V>parent;TreeNode<K,V>left;TreeNode<K,V>right;TreeNode<K,V>prev;booleanred;......}......}41HashMap是基于哈希表实现的，每一个元素是一个key-value对。p底层是一个Node生hash冲突的时候，hashap来解决的，在对应的数组位置存放链表的头结点。认为1）时，会自动增长。HashMap用concurrent并发包下的concrrentHashMa。Hash函数的实现：值及其作用：size：记录HashMap的底层数组中已用槽的数量。U为0.一当loadFactor大于1时，会发生碰撞；当loadFactor，）threshold是HashMap的值用判断否要调整HashMap量（threshold=容量*。42TREEIFY_THESHOL：链表转化为红黑树的阈值（这个值时，需要使用红黑树节点替换链表节点。UNTREEIFY_RESHLDnode的个数小于这个值，就会把树还原（切分）为链表结构。MIN_TREEIFY_CAPACITY组的长度大于这个值时，才会将链表转红黑树。put过程：1如果当前map中无数据，执行resize方法；2.如果要插入的键值对要存放的这个位置刚好没有元素，那么把他封装成Node对象，并放在这个位置上；3如果发生碰撞，判断node的类型是红黑树还是链表；3.1如果为红黑树，则将V对插在红黑树对应的位置3.2如果为链表，遍历链表（有三个if判断）a.如果为链表最后一个node，则将新的node节点插入到链表尾；b.插入完后，如果链表的node数量大于，将表为红树操作；如果当前哈希表为空或数组长度小于6，会扩容；否则转化为红黑树。后将链表转化为红黑树。c遍历链表时，如果y已存在，则直接break循环。4判断是否要扩容；5返回。HashMap中y和value都允许为null。y为null以table[0]为头结点的链表中。gt过程：对y的hashCode()做hash算indx果bt个节点直接命中则返回；2如果有冲突，则通过key.equals()去查找对应的entry。若为树，则在树中通过key.equals()查找。若为链表，则在链表中通过key.equals()查找。ee过程：对y的hashCode()做hash，然后再计算index；如果node==null返到y和hash相等的node果node；如果为链表，则从链表中删除。43如何确定y在数组的位置？法算在HashMap中通过h&(n-1)得是2的整数倍）扩容机制：1数组容量扩大一倍2遍历旧的数组（有三个if判断）a.如果node的nt的ne的位；b.如果node的next为红黑树变个(i+oldCap)新点于树转化为链表；否则，将新生成的链表转红黑树。c如果node的next为表则据hash&oldap==0)将node两(i+oldCap)中链表的头节点分别指向它们。3返回扩容后的数组。hashmap扩容情况：1.put操作时，如果map数组的长度为0；2发生碰撞，且链表转红黑树判断时，数组的长度小于64时；3当V对的个数大于加载因子*数组的长度。44我们分析下为什么哈希表的容量一定要是2的整数次幂？hashmap根据h&length-1)计算node，果length不为2，其对应的二进制数有为0的位，这样会导致二进制为0的位置永远存不了数据，加hash。如何保证容量为2的N次方的？staticfinalinttableSizeFor(intcap){intn=cap-1;n|=n>>>1;n|=n>>>2;n|=n>>>4;n|=n>>>8;n|=n>>>16;return(n<0)?1:(n>=MAXIMUM_CAPACITY)?MAXIMUM_CAPACITY:n+1;}1对于容量ap个1如01xxxxxx；2在和自身右移一位做或运算之后，能保证第一个1的后面一位也是1，这样就有连续的两位是1了，即01xxxxxx|001xxxxx=011xxxxx；3同理，依次做或运算之后，能保证最高是1的那一位之后的所有位都是1，即011xxxxx|00011xx=01111xx，直至得到0；4最后，再进行n+1就得到了大于当前数的下一个2的N次方。5第一步的n=cap-1是为了让本身是2的N次方的数，得到的结果还是自己。t机制：java.util.HashMap不线安的，此果在用代的过中其他线程修改了map出ConcurrntMoificationception谓f-fast策略。HashMap序列化：读写Map是根据h&(n-1)来确定，而Object.hashcode()是native方法,不同的M里可能是不一样的，所以要重写序列化方法。备注：jdk7碰撞时，node插头，种情在线程容产死环；jdk8插在尾部。4511、TreeMappublicclassTreeMap<K,V>extendsAbstractMap<K,V>implementsNavigableMap<K,V>,Cloneable,java.io.Serializable{privatefinalComparator<?superK>comparator;privatetransientEntry<K,V>root;staticfinalclassEntry<K,V>implementsMap.Entry<K,V>{Kkey;Vvalue;Entry<K,V>left;Entry<K,V>right;Entry<K,V>parent;booleancolor=BLACK;......}......}Teap底层以一颗红黑树实现。y不能为空，非线程安全。以y对应的Comparator排序。46左旋的过程是将x的右子树绕x逆时针旋转，使得x的右子树成为x父亲，同