1.javaå·¥ä½åç
2.JVM详解之:HotSpot VM中的源码Intrinsic methods
3.Java热部署之实现SpringBoot的feign热部署
4.java并发编程之深入学习Concurrent包(十一,ConcurrentLinkedQueue类)
5.面试必问的源码CAS,你懂了吗?
6.Java之Unsafe-越迷人的源码越危险
javaå·¥ä½åç
Javaå·¥ä½åç
ç±åæ¹é¢ç»æï¼
ï¼1ï¼Javaç¼ç¨è¯è¨
ï¼2ï¼Javaç±»æä»¶æ ¼å¼
ï¼3ï¼Javaèææº
ï¼4ï¼Javaåºç¨ç¨åºæ¥å£
å½ç¼è¾å¹¶è¿è¡ä¸ä¸ªJavaç¨åºæ¶ï¼éè¦åæ¶æ¶åå°è¿åç§æ¹é¢ã使ç¨æåç¼è¾è½¯ä»¶ï¼ä¾å¦è®°äºæ¬ãååæ¿ãUltraEditçï¼æéæå¼åç¯å¢ï¼EclipseãMyEclipseçï¼å¨Javaæºæ件ä¸å®ä¹ä¸åçç±» ï¼éè¿è°ç¨ç±»ï¼è¿äºç±»å®ç°äºJava APIï¼ä¸çæ¹æ³æ¥è®¿é®èµæºç³»ç»ï¼ææºæ件ç¼è¯çæä¸ç§äºè¿å¶ä¸é´ç ï¼åå¨å¨classæ件ä¸ï¼ç¶ååéè¿è¿è¡ä¸æä½ç³»ç»å¹³å°ç¯å¢ç¸å¯¹åºçJavaèææºæ¥è¿è¡classæ件ï¼æ§è¡ç¼è¯äº§ççåèç ï¼è°ç¨classæ件ä¸å®ç°çæ¹æ³æ¥æ»¡è¶³ç¨åºçJava APIè°ç¨ ã
JVM详解之:HotSpot VM中的Intrinsic methods
内置方法是编译器内置的方法实现,它们在给定编程语言中使用,源码由编译器专门处理。源码内置方法通常在程序请求优化时才启用,源码新股开板选股公式源码以提高效率。源码因为内置方法是源码在编译器内部实现的,所以不同的源码虚拟机,其内置方法是源码不一样的。内置方法可以在Java源代码级别看起来与非内置方法一样,源码但它们的源码区别在于JVM的实现。有些方法在普通Java代码中无法实现,源码如sun.misc.Unsafe.compareAndSwapInt(),源码只能通过JNI或内置方法来实现,源码实现对Java语义的扩展。在Hotspot VM中,内置方法通常在src/share/vm/classfile/vmSymbols.hpp类中。通过参数查看代码中调用的方法是否为内置方法,或者通过底层汇编语言查看。内置方法大部分都是内联方法,通过减少函数调用开销的技术实现。内置方法的实现由三种编译器完成:javac将Java源代码编译成为字节码,在这一层只有数学方法和bootstrapping的MethodHandle实现;JIT的Client Compiler (C1);JIT的Server Compiler (C2)。例如,java.lang.System.currentTimeMillis()方法在Interpreter级别没有intrinsified,因为它是一个native方法,通过JNI调用底层的C++实现。而在C1和C2级别使用intrinsified,直接调用os::javaTimeMillis(),减少JNI的c ide源码使用,提升效率。内置方法的实现可以通过修改底层的JVM实现完成。Graal是一个用Java编写的JIT编译器,可以使用Java来实现Intrinsic方法,对于不熟悉C++的开发者来说非常友好。通过Graal,内置方法的实现变得简单且容易操作。内置方法是JVM中非常有用的特性,能够显著提高程序效率,是编程时值得考虑的技术之一。
Java热部署之实现SpringBoot的feign热部署
Java热部署,即在应用运行时动态更新类文件并实时生效,无需重启,对SpringBoot中的Feign服务尤其适用。Feign作为SpringCloud中用于简化HTTP API开发的声明式客户端,其重要性随着微服务的流行而提升。在微服务架构中,不同服务间通信频繁,Feign支持负载均衡,通过配置文件调用指定服务。
在开发过程中,我们通常需要在feign服务的url中配置特定地址,但当需求变化时,重启服务显得低效。这时,HotswapAgent框架及其针对Feign的热部署插件登场,只需在启动参数中添加相应jar,就能在resources目录下配置hotswap-feign.properties文件,实时修改Feign服务的url,无需重启服务,保定麻将源码极大地提高了开发效率。
热部署的实现原理简单:当文件被重新编译,HotswapAgent会检测到变化并触发事件,将事件传递给感兴趣的插件,如修改Feign服务url的插件。源码可以在GitHub或Gitee上获取,实现了一个无需重启即可实时更新Feign服务配置的解决方案,实现了真正的沉浸式开发体验。
java并发编程之深入学习Concurrent包(十一,ConcurrentLinkedQueue类)
深入学习ConcurrentLinkedQueue类,了解它作为非阻塞队列实现,采用链表形式构建的容器。
ConcurrentLinkedQueue类遵循非阻塞算法,通过原子指令CAS(Compare and Swap)取代同步阻塞锁,以确保在并发访问下数据的一致性,并显著提升同步性能。根据Amdahl定律,最小化串行代码的粒度是提升并发性能的关键,ConcurrentLinkedQueue类的实现正是如此。它不严格保证链表头尾的一致性,而是通过CAS操作来确保新节点的插入和头尾节点的更新,实现高效并发。
在非阻塞队列的操作中,通常需要原子化执行的两个步骤被分离,即插入新节点的入队和出队操作,与头尾节点的更新并非同步。这减少了需要原子更新的值范围,仅涉及唯一的变量,从而提升了非阻塞队列操作的性能,这也是公安asp源码Amdahl定律的体现。
ConcurrentLinkedQueue类的源代码中,节点类Node实现了这一设计,其item和next域被声明为普通的volatile类型,并使用AtomicReferenceFieldUpdater来更新。通过这种方式,能够实现高效、并发的节点操作。
节点类型被分为有效节点(item不为null)、无效节点(item为null)和已删除节点(通过next链接到自身),其中,头节点是队列中的第一个有效节点,而尾节点是next为null的节点,注意这不一定是tail指向的节点。
队列的初始化通过创建一个head和tail共同指向,item及next都为null的初始队列来实现。
入队操作涉及将新节点插入到尾节点的后面,通过tail找到尾节点执行插入操作。如果插入不成功,会继续向后推进查找。这一过程确保了高效并发的实现。
出队操作则涉及从头节点开始,循环查找下一个节点,直到找到满足条件的节点为止。一旦找到满足条件的节点,则更新头节点,并返回该节点的item值。
当遍历过程已越过一个节点时,会寻找下一个节点。如果head的next等于head,则意味着到达了哨兵节点,geth源码反洗此时下一节点从head重新开始查找。
综上所述,ConcurrentLinkedQueue类通过非阻塞算法和高效的设计,提供了一个高性能的并发队列实现,适用于需要高并发访问场景的应用。
面试必问的CAS,你懂了吗?
CAS(Compare-and-Swap)是一种实现并发算法时常用的技术,Java并发包中的多个类采用了CAS技术。面试中经常涉及这一概念,本文旨在深入解析CAS的原理。
在介绍CAS之前,我们通过一个例子来理解其应用。这个例子在运行过程中可能会陷入死循环,通过检查线程状态,发现IDEA监控线程的介入导致了问题。解决这一死循环的方法是使用DEBUG模式运行程序或调整代码逻辑。
通过volatile关键字的使用,我们可以观察到,其只能确保可见性,而不能保证原子性。在并发场景下,对于自增操作等非原子操作,volatile并不能保证正确结果。因此,解决这类问题的关键是引入原子操作。
引入synchronized关键字是一种常见的解决方法,通过加锁实现原子操作,确保每次操作的正确性。然而,频繁使用synchronized会导致性能下降,因此引入Java并发包中的原子操作类(如AtomicInteger)成为了更优选择。
AtomicInteger的`getAndIncrement()`方法即是CAS操作的实例,它通过一系列原子操作确保每次自增操作的正确性和性能。进一步分析,我们发现其底层实现调用了`compareAndSwapInt`方法,即CAS的核心实现。
CAS(Compare-and-Swap)本质上是一个比较并替换操作,它需要三个操作数:内存地址、旧的预期值和目标值。执行过程中,当内存地址的值与预期值相等时,CAS尝试将内存地址的值修改为目标值。若失败,则获取最新值,重新尝试,直至修改成功。
深入到源码层面,可以看到`AtomicInteger`类中的`getAndIncrement()`方法最终调用了`compareAndSwapInt`方法,而`compareAndSwapInt`在Unsafe类中被实现。通过调用`Atomic::cmpxchg`方法,我们能够看到具体的汇编指令实现。
`Atomic::cmpxchg`方法的实现依赖于系统是否为多处理器环境,以优化性能。它通过`LOCK_IF_MP`宏决定是否添加`lock`前缀,这一优化措施在单处理器环境下通常没有必要,但在多核处理器中能够提升性能。
CAS操作的缺点包括循环时间长导致的开销大、仅支持单一共享变量的原子操作,以及ABA问题。ABA问题是由于CAS操作的特性导致,即在读取值后,值在后续操作中可能被改回原始值,从而产生误判。为解决ABA问题,Java并发包提供了带有版本控制的原子引用类`AtomicStampedReference`。
在使用CAS操作时,需要考虑其对并发正确性的影响,尤其是ABA问题。如果并发场景中存在可能的ABA问题,传统互斥同步可能比原子类更高效。
综上所述,理解CAS的原理和其在并发编程中的应用对于深入学习Java并发技术至关重要。掌握CAS操作的原理、优缺点及其解决方法,将有助于更高效、正确地处理并发问题。
Java之Unsafe-越迷人的越危险
简要介绍:
Java语言先比较与C和C++有一个非常大的不同点在于Java语言无法直接操作内存,实际开发中,默认都是由JVM来进行内存分配和垃圾回收,而JVM在进行垃圾回收的时候,绝大多数垃圾回收器都需要STW(stop the world)这个问题往往会导致服务短暂或者较长时间的暂停。因此Unsafe提供了通过Java直接操作内存的API,尽管Unsafe是JavaNIO和并发的核心类,但是其如其名,这是一个官方不推荐开发者使用的及其不安全的类!
主要作用:序号作用API1内存管理。(包括分配内存、释放内存等。)allocateMemory(分配内存)、reallocateMemory(重新分配内存)、copyMemory(拷贝内存)、freeMemory(释放内存 )、getAddress(获取内存地址)、addressSize、pageSize、getInt(获取内存地址指向的整数)、getIntVolatile(获取内存地址指向的整数,并支持volatile语义)、putInt(将整数写入指定内存地址)、putIntVolatile(将整数写入指定内存地址,并支持volatile语义)、putOrderedInt(将整数写入指定内存地址、有序或者有延迟的方法)2非常规的对象实例化allocateInstance()方法提供了另一种创建实例的途径3操作类、对象、变量staticFieldOffset(静态域偏移)、defineClass(定义类)、defineAnonymousClass(定义匿名类)、ensureClassInitialized(确保类初始化)、objectFieldOffset(对象域偏移)4数组操作arrayBaseOffset(获取数组第一个元素的偏移地址)、arrayIndexScale(获取数组中元素的增量地址)等方法5多线程同步。包括锁机制、CAS操作等monitorEnter、tryMonitorEnter、monitorExit、compareAndSwapInt、compareAndSwap6挂起与恢复park、unpark7内存屏障loadFence、storeFence、fullFence一、获取Unsafe源码-基于jdk1.8/**在Unsafe源码中限制了获取Unsafe的ClassLoader,如果这个方法调用实例不是由BootStrap类加载器加载的,则会报错*因此,我们如果需要使用Unsafe类,可以通过反射的方式来获取。*/@CallerSensitivepublicstaticUnsafegetUnsafe(){ Classvar0=Reflection.getCallerClass();//此处会判断ClassLoader是否为空,BootStrap由C语言编写,在Java中获取会返回null。if(!VM.isSystemDomainLoader(var0.getClassLoader())){ thrownewSecurityException("Unsafe");}else{ returntheUnsafe;}}获取方式/***反射获取Unsafe**@returnUnsafe*/publicstaticfinalUnsafegetUnsafe(){ Unsafeunsafe=null;try{ FieldtheUnsafe=Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);unsafe=(Unsafe)theUnsafe.get(null);}catch(NoSuchFieldException|IllegalAccessExceptione){ e.printStackTrace();}returnunsafe;}二、操作方法数组操作packagecom.liziba.unsafe;importsun.misc.Unsafe;/***<p>*操作数组示例*</p>**@Author:Liziba*@Date:/5/:*/publicclassOperateArrayExample{ /***1、publicnativeintarrayBaseOffset(Class<?>var1);获取数组第一个元素的偏移地址*2、publicnativeintarrayIndexScale(Class<?>var1);获取数组中元素的增量地址*3、publicObjectgetObject(Objectvar1,intvar2);通过对象和地址偏移量获取元素*/publicstaticvoidoperateArrayUseUnsafe(){ //测试数组String[]exampleArray=newString[]{ "李","子","捌"};Unsafeunsafe=UnsafeFactory.getUnsafe();//获取数组的基本偏移量intbaseOffset=unsafe.arrayBaseOffset(String[].class);System.out.println("String[]baseoffsetis:"+baseOffset);//获取数组中元素的增量地址intscale=unsafe.arrayIndexScale(String[].class);System.out.println("String[]indexscaleis:"+scale);//获取数组中第n个元素i=(baseOffset+(scale*n-1))System.out.println("thirdelementis:"+unsafe.getObject(exampleArray,baseOffset+(scale*2)));//修改数组中第n个元素i=(baseOffset+(scale*n-1))unsafe.putObject(exampleArray,baseOffset+scale*2,"柒");System.out.println("thirdelementis:"+unsafe.getObject(exampleArray,baseOffset+(scale*2)));}publicstaticvoidmain(String[]args){ OperateArrayExample.operateArrayUseUnsafe();}}输出结果
对象操作packagecom.liziba.unsafe;importcom.liziba.unsafe.pojo.User;importsun.misc.Unsafe;importjava.io.File;importjava.io.FileInputStream;importjava.lang.reflect.Constructor;importjava.lang.reflect.Field;/***<p>*操作对象示例*</p>**@Author:Liziba*@Date:/5/:*/publicclassOperateObjectExample{ /***1、publicnativeObjectallocateInstance(Class<?>var1);分配内存*2、publicnativeClass<?>defineClass(Stringvar1,byte[]var2,intvar3,intvar4,ClassLoadervar5,ProtectionDomainvar6);方法定义一个类用于动态的创建类*@throwsException*/publicstaticvoidoperateObjectUseUnsafe()throwsException{ Unsafeunsafe=UnsafeFactory.getUnsafe();//使用Unsafe的allocateInstance()方法,可以无需使用构造函数的情况下实例化对象Useruser=(User)unsafe.allocateInstance(User.class);user.setId(1);user.setName("李子捌");System.out.println(user);//返回对象成员属性在内存中相对于对象在内存中地址的偏移量Fieldname=User.class.getDeclaredField("name");longfieldOffset=unsafe.objectFieldOffset(name);//使用Unsafe的putXxx()方法,可以直接修改内存地址指向的数据(可以越过权限访问控制符)unsafe.putObject(user,fieldOffset,"李子柒");System.out.println(user);//使用Unsafe在运行时通过.class文件,创建类FileclassFile=newFile("E:\workspaceall\liziba-javap5\out\production\liziba-javap5\com\liziba\unsafe\pojo\User.class");FileInputStreamfis=newFileInputStream(classFile);byte[]classContent=newbyte[(int)classFile.length()];fis.read(classContent);Class<?>clazz=unsafe.defineClass(null,classContent,0,classContent.length,null,null);Constructor<?>constructor=clazz.getDeclaredConstructor(int.class,String.class);System.out.println(constructor.newInstance(1,"李子玖"));}publicstaticvoidmain(String[]args){ try{ OperateObjectExample.operateObjectUseUnsafe();}catch(Exceptione){ e.printStackTrace();}}}输出结果
内存操作packagecom.liziba.unsafe;importsun.misc.Unsafe;/***<p>*内存地址操作示例*</p>**@Author:Liziba*@Date:/5/:*/publicclassOperateMemoryExample{ /***1、publicnativelongallocateMemory(longvar1);分配var1字节大小的内存,返回起始地址偏移量*2、publicnativelongreallocateMemory(longvar1,longvar3);重新给var1起始地址的内存分配长度为var3字节的内存,返回新的内存起始地址偏移量*3、publicnativevoidfreeMemory(longvar1);释放起始地址为var1的地址**分配地址的方法还有重分配,都是分配在堆外内存,返回的是一个long类型的地址偏移量。这个偏移量在Java程序中的每一块内存都是唯一的**/publicstaticvoidoperateMemoryUseUnsafe(){ Unsafeunsafe=UnsafeFactory.getUnsafe();//申请分配8byte的内存longaddress=unsafe.allocateMemory(1L);//初始化内存填充值unsafe.putByte(address,(byte)1);//测试输出System.out.println(newStringBuilder().append("address:").append(address).append("bytevalue:").append(unsafe.getByte(address)));//重新分配一个地址longnewAddress=unsafe.reallocateMemory(address,8L);unsafe.putLong(newAddress,L);System.out.println(newStringBuilder().append("address:").append(newAddress).append("longvalue:").append(unsafe.getLong(newAddress)));//释放地址,注意地址可能被其他使用unsafe.freeMemory(newAddress);System.out.println(newStringBuilder().append("address:").append(newAddress).append("longvalue:").append(unsafe.getLong(newAddress)));}publicstaticvoidmain(String[]args){ OperateMemoryExample.operateMemoryUseUnsafe();}}输出结果
CAS操作packagecom.liziba.unsafe;importcom.liziba.unsafe.pojo.User;importsun.misc.Unsafe;importjava.lang.reflect.Field;/***<p>*CAS操作示例*</p>**@Author:Liziba*@Date:/5/:*/publicclassOperateCASExample{ /***CAS==compareandswap(比较并替换)*当需要改变的值为期望值的时候,就替换为新的值,是原子(不可再分割)操作。Java中大量的并发框架底层使用到了CAS操作。*优势:无锁操作,减少线程切换带来的开销*缺点:CAS容易在并发的情况下失败从而引发性能问题,也存在ABA问题。**Unsafe中提供了三个方法*1、compareAndSwapInt*2、compareAndSwapLong*3、compareAndSwapObject**/publicstaticvoidoperateCASUseUnsafe()throwsException{ Useruser=newUser(1,"李子捌");System.out.println("preuservalue:"+user);Unsafeunsafe=UnsafeFactory.getUnsafe();Fieldid=user.getClass().getDeclaredField("id");Fieldname=user.getClass().getDeclaredField("name");//获取ID字段的内存偏移量longidFieldOffset=unsafe.objectFieldOffset(id);//获取name字段的内存偏移量longnameFieldOffset=unsafe.objectFieldOffset(name);//如果ID的期望值是1,则修改为successunsafe.compareAndSwapInt(user,idFieldOffset,1,);//如果name的期望值是小荔枝,则修改为李子柒failunsafe.compareAndSwapObject(user,nameFieldOffset,"小荔枝","李子柒");//输出修改的user对象System.out.println("postuservalue:"+user);}publicstaticvoidmain(String[]args){ try{ OperateCASExample.operateCASUseUnsafe();}catch(Exceptione){ e.printStackTrace();}}}输出结果
线程的挂起和恢复/***查看Java的java.util.concurrent.locks.LockSupport源代码可以发现LockSupport类*中有各种版本的pack方法但是最终都是通过调用Unsafe.park()方法实现的。*/publicclassLockSupport{ publicstaticvoidunpark(Threadthread){ if(thread!=null)UNSAFE.unpark(thread);}publicstaticvoidpark(Objectblocker){ Threadt=Thread.currentThread();setBlocker(t,blocker);UNSAFE.park(false,0L);setBlocker(t,null);}publicstaticvoidparkNanos(Objectblocker,longnanos){ if(nanos>0){ Threadt=Thread.currentThread();setBlocker(t,blocker);UNSAFE.park(false,nanos);setBlocker(t,null);}}publicstaticvoidparkNanos(longnanos){ if(nanos>0)UNSAFE.park(false,nanos);}publicstaticvoidparkUntil(Objectblocker,longdeadline){ Threadt=Thread.currentThread();setBlocker(t,blocker);UNSAFE.park(true,deadline);setBlocker(t,null);}publicstaticvoidparkUntil(longdeadline){ UNSAFE.park(true,deadline);}}我们平时如何实现浅克隆?
实现Closeable接口
重写close()方法
一、Unsafe实现浅克隆浅克隆工具类packagecom.liziba.unsafe.clone;importcom.liziba.unsafe.UnsafeFactory;importsun.misc.Unsafe;importjava.lang.reflect.Field;importjava.lang.reflect.Modifier;importjava.util.Arrays;/***<p>*浅克隆工具类*</p>**@Author:Liziba*@Date:/5/:*/publicclassShallowCloneUtil{ /***获取对象的内存地址**@Description*Unsafe类没有提供直接获取实例对象内存地址的方法,但是可以通过以下方式间接获取。*构建对象A,A包含了我们需要获取内存地址的B对象的引用,这样只有获取到A对象持有的B对象的引用地址,就可以知道B对象的地址了。*我们可以通过Unsafe类获取内存地址的方法publicnativelonggetLong(Objectvar1,longvar2)来获取;*此处我们为了方便,通过数组Object[]添加Object元素,持有Object的引用**@return*/publicstaticLonggetAddress(Objectobj){ Object[]objects=newObject[]{ obj};Unsafeunsafe=UnsafeFactory.getUnsafe();intarrayBaseOffset=unsafe.arrayBaseOffset(Object[].class);returnunsafe.getLong(objects,arrayBaseOffset);}/***获取对象的大小**@Dscription*Java中实例化一个对象时,JVM会在堆中分配非static的Field的内存,其他的static属性或者method在类加载期间或者JVM启动时已经存放在内存中。*所以我们计算对象的大小的时候只需要求和Field的大小就行了,JVM分配内存时,单个实例对象中的Field内存是连续不断地,*因此我们只需获取最大偏移量Filed的偏移量+最大偏移量Filed本身的大小即可**Java中基本数据类型所占的字节数*byte/boolean1字节*char/short2字节*int/float4字节*long/double8字节*boolean理论上占1/8字节,实际上按照1byte处理。*Java采用的是Unicode编码,每一个字节占8位,一个字节由8个二进制位组成。**@paramclazz*@return*/publicstaticLongsize(Classclazz){ //最后一个Filed的内存偏移量longmaxOffset=0;ClasslastFiledClass=null;Unsafeunsafe=UnsafeFactory.getUnsafe();do{ for(Fieldfield:clazz.getDeclaredFields()){ if(!Modifier.isStatic(field.getModifiers())){ longtmpOffset=unsafe.objectFieldOffset(field);if(tmpOffset>maxOffset){ maxOffset=tmpOffset;lastFiledClass=field.getType();}}}}while((clazz=clazz.getSuperclass())!=null);//最后一个Field本身的大小intlastFiledSize=(boolean.class.equals(lastFiledClass)||byte.class.equals(lastFiledClass))?1:(short.class.equals(lastFiledClass)||char.class.equals(lastFiledClass))?2:(int.class.equals(lastFiledClass)||float.class.equals(lastFiledClass))?4:8;returnmaxOffset+lastFiledSize;}/***申请一块固定大小的内存空间**@Description*通过Unsafe的publicnat