javaunsafe

1. 如何获得java对象的内存地址

在java中内存中的对象地址是可变的，所以获得的内存地址有可能会变化。要获得内存地址也只能通过Unsafe的方法来获得，如下代码示例：

packagecom.bijian.study;

importjava.lang.reflect.Field;

importsun.misc.Unsafe;

publicclassAddresser{

//实例化Unsafe 类

privatestaticUnsafeunsafe;

static{

try{

//得到field对象

Fieldfield=Unsafe.class.getDeclaredField("theUnsafe");

//设置获取地址

field.setAccessible(true);

unsafe=(Unsafe)field.get(null);

}catch(Exceptione){

e.printStackTrace();

}

}

publicstaticlongaddressOf(Objecto)throwsException{

Object[]array=newObject[]{o};

longbaseOffset=unsafe.arrayBaseOffset(Object[].class);

intaddressSize=unsafe.addressSize();

longobjectAddress;

switch(addressSize){

case4:

objectAddress=unsafe.getInt(array,baseOffset);

break;

case8:

objectAddress=unsafe.getLong(array,baseOffset);

break;

default:

thrownewError("unsupportedaddresssize:"+addressSize);

}

return(objectAddress);

}

//打印地址的长度

publicstaticvoidmain(String...args)throwsException{

Objectmine="Hithere".toCharArray();

longaddress=addressOf(mine);

System.out.println("Addess:"+address);

//Verifyaddressworks-

printBytes(address,27);

}

//调用此方法得到地址

publicstaticvoidprintBytes(longobjectAddress,intnum){

//循环打印得到的地址。

for(longi=0;i<num;i++){

intcur=unsafe.getByte(objectAddress+i);

System.out.print((char)cur);

}

System.out.println();

}

}

运行结果：

2. JAVA POI 使用addMergedRegionUnsafe合并单元格操作导致导出时间大大增加，怎么解决

可以逻辑合并，直接把excel文件后缀名改zip，进去后进入目录xl/sheet目录下，打开sheet1.xml如下

这是横向合并，spans="1:2"中的1代表第1行2代表合并ab两列,具体可以根据代码逻辑修改，这种直接修改源文件的方式是效率最快的，逻辑也是最复杂的，具体看自己取舍吧

3. Java 的 DirectBuffer 是什么东西

DirectByteBuffer 类有一个内部的静态类 Deallocator，这个类实现了 Runnable 接口并在 run() 方法内释放了内存：?View CodeJAVA unsafe.freeMemory(address); 那这个 Deallocator 线程是哪里调用了呢？这里就用到了 Java 的虚引用（PhantomReference），Java 虚引用允许对象被回收之前做一些清理工作。在 DirectByteBuffer 的构造方法中创建了一个 Cleaner：?View CodeJAVA cleaner = Cleaner.create(this , new Deallocator(address, cap) ); 而Cleaner 类继承了 PhantomReference 类，并且在自己的 clean() 方法中启动了清理线程，当 DirectByteBuffer 被 GC 之前 cleaner 对象会被放入一个引用队列（ReferenceQueue），JVM 会启动一个低优先级线程扫描这个队列，并且执行 Cleaner 的 clean 方法来做清理工作。OK，DirectByteBuffer 的实现大概搞清楚了，那我们是否该在自己的代码中使用 DirectByteBuffer 呢？我个人认为可以适当的使用，使用直接内存确实避免了 GC 问题和内存拷贝的问题，但是我们不得不考虑两个问题：1）操作系统可能会把 DirectByteBuffer 的内存交换到磁盘上，这样势必会影响性能，为了避免这个问题我们不得不对操作系统做相应的配置；2）DirectByteBuffer 申请内存失败会直接抛出 OutOfMemoryError，对于这种情况，还是要想办法处理。

4. Java为什么会引入及如何使用Unsafe

通常我们所说的网站在线客服系统一般是基于网页的即时通讯工具,它不需要安装任何软件,只需要在浏览器窗口就可以进行实时交谈。网站在线客服系统作为企业网站的客服服务和主动营销工具,他必须具有主动营销、客服支持及客户关系管理方面的功能.结合各类统计数据及历史资料，可以使企业针对每一位网站页面的访客建立档案以便提供个性化服务，达到变访客为客户的营销目的，使公司形象更为专业化。
在线客服系统给企业带来了优势，让企业和流量有了交流的接口，推荐使用乐盈通客服系统，是一个智能的沟通平台，有效帮助企业实现在线客服的完美服务。

5. 如何使用Unsafe操作内存中的Java类和对象

本文由 ImportNew - 吴际 翻译自 zeroturnaround。欢迎加入翻译小组。转载请参见文章末尾的要求。

让我们开始展示内存中Java类和对象结构
你可曾好奇过Java内存管理核心构件？你是否问过自己某些奇怪的问题，比如：
一个类在内存中占据多少空间？
我的对象在内存中消耗了多少空间？
对象的属性在内存中是如何被布局的？
如果这些问题听起来很熟悉，那么你就想到了点子上。对于像我们这样的在RebelLabs的Java极客来说，这些难解的谜题已经在我们脑海中缠绕了很长时间：如果你对探究类检测器感兴趣，想知道如何布局让所有的类更容易地从内存中取到指定变量，或是想在系统运行时侵入内存中的这些字段。这就意味着你能切实改变内存中的数据甚至是代码！
其它可能勾起你兴趣的知识点有，“堆外缓存”和“高性能序列化”的实现。这是一对构建在对象缓存结构上很好的实例，揭示了获取类和实例内存地址的方法，缓存中类和实例的布局以及关于对象成员变量布局的详细解释。我们希望尽可能简单地阐释这些内容，但是尽管如此这篇文章并不适合Java初学者，它要求具备对Java编程原理有一定的了解。
注意：下面关于类和对象的布局所写的内容特指Java SE 7，所以不推荐使用者想当然地认为这些适用于过去或将来的Java版本。方便起见，我们在GitHub项目上发布了这篇文章的示例代码，可以在这里找到 https://github.com/serkan-ozal/ocean-of-memories/tree/master/src/main/java/com/zeroturnaround/rebellabs/oceanofmemories/article1。
在Java中最直接的内存操作方法是什么？
Java最初被设计为一种安全的受控环境。尽管如此，Java HotSpot还是包含了一个“后门”，提供了一些可以直接操控内存和线程的低层次操作。这个后门类——sun.misc.Unsafe——被JDK广泛用于自己的包中，如java.nio和java.util.concurrent。但是丝毫不建议在生产环境中使用这个后门。因为这个API十分不安全、不轻便、而且不稳定。这个不安全的类提供了一个观察HotSpot JVM内部结构并且可以对其进行修改。有时它可以被用来在不适用C++调试的情况下学习虚拟机内部结构，有时也可以被拿来做性能监控和开发工具。
为何变得不安全
sun.misc.Unsafe这个类是如此地不安全，以至于JDK开发者增加了很多特殊限制来访问它。它的构造器是私有的，工厂方法getUnsafe()的调用器只能被Bootloader加载。如你在下面代码片段的第8行所见，这个家伙甚至没有被任何类加载器加载，所以它的类加载器是null。它会抛出SecurityException 异常来阻止侵入者。
public final class Unsafe {
...
private Unsafe() {}
private static final Unsafe theUnsafe = new Unsafe();
...
public static Unsafe getUnsafe() {
Class cc = sun.reflect.Reflection.getCallerClass(2);
if (cc.getClassLoader() != null)
throw new SecurityException("Unsafe");
return theUnsafe;
}
...
}

幸运的是这里有一个Unsafe的变量可以被用来取得Unsafe的实例。我们可以轻松地编写一个复制方法通过反射来实现，如下所示：
（http://highlyscalable.wordpress.com/2012/02/02/direct-memory-access-in-java/）
public static Unsafe getUnsafe() {
try {
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
return (Unsafe)f.get(null);
} catch (Exception e) {
/* ... */
}
}

Unsafe一些有用的特性
虚拟机“集约化”（VM intrinsification）：如用于无锁Hash表中的CAS（比较和交换）。再比如compareAndSwapInt这个方法用JNI调用，包含了对CAS有特殊引导的本地代码。在这里你能读到更多关于CAS的信息：http://en.wikipedia.org/wiki/Compare-and-swap。
主机虚拟机（译注：主机虚拟机主要用来管理其他虚拟机。而虚拟平台我们看到只有guest VM）的sun.misc.Unsafe功能能够被用于未初始化的对象分配内存（用allocateInstance方法），然后将构造器调用解释为其他方法的调用。
你可以从本地内存地址中追踪到这些数据。使用java.lang.Unsafe类获取内存地址是可能的。而且可以通过unsafe方法直接操作这些变量！
使用allocateMemory方法，内存可以被分配到堆外。例如当allocateDirect方法被调用时DirectByteBuffer构造器内部会使用allocateMemory。
arrayBaseOffset和arrayIndexScale方法可以被用于开发arraylets，一种用来将大数组分解为小对象、限制扫描的实时消耗或者在大对象上做更新和移动。

6. 求教java中的unsafe.allocateMemory 会导致内存申请失败吗

没有java，这条进程是grep java 的进程，不是java的

用户名 PID SID 进程的cpu占用率 进程启动时间和日期 与进程关联的终端（tty） 进程使用的总cpu时间 正在执行的命令行命令

7. Java为什么会引入及如何使用Unsafe

sun.misc.Unsafe至少从2004年Java1.4开始就存在于Java中了。在Java9中，为了提高JVM的可维护性，Unsafe和许多其他的东西一起都被作为内部使用类隐藏起来了。但是究竟是什么取代Unsafe不得而知，个人推测会有不止一样来取代它，那么问题来了，到底为什么要使用Unsafe？
做一些Java语言不允许但是又十分有用的事情
很多低级语言中可用的技巧在Java中都是不被允许的。对大多数开发者而言这是件好事，既可以拯救你，也可以拯救你的同事们。同样也使得导入开源代码更容易了，因为你能掌握它们可以造成的最大的灾难上限。或者至少明确你可以不小心失误的界限。如果你尝试地足够努力，你也能造成损害。
那你可能会奇怪，为什么还要去尝试呢？当建立库时，Unsafe中很多（但不是所有）方法都很有用，且有些情况下，除了使用JNI，没有其他方法做同样的事情，即使它可能会更加危险同时也会失去Java的“一次编译，永久运行”的跨平台特性。
对象的反序列化
当使用框架反序列化或者构建对象时，会假设从已存在的对象中重建，你期望使用反射来调用类的设置函数，或者更准确一点是能直接设置内部字段甚至是final字段的函数。问题是你想创建一个对象的实例，但你实际上又不需要构造函数，因为它可能会使问题更加困难而且会有副作用。
public class A implements Serializable {
private final int num;
public A(int num) {
System.out.println("Hello Mum");
this.num = num;
}
public int getNum() {
return num;
}
}
在这个类中，应该能够重建和设置final字段，但如果你不得不调用构造函数时，它就可能做一些和反序列化无关的事情。有了这些原因，很多库使用Unsafe创建实例而不是调用构造函数。
Unsafe unsafe = getUnsafe();
Class aClass = A.class;
A a = (A) unsafe.allocateInstance(aClass);
调用allocateInstance函数避免了在我们不需要构造函数的时候却调用它。
线程安全的直接获取内存
Unsafe的另外一个用途是线程安全的获取非堆内存。ByteBuffer函数也能使你安全的获取非堆内存或是DirectMemory，但它不会提供任何线程安全的操作。你在进程间共享数据时使用Unsafe尤其有用。

import sun.misc.Unsafe;
import sun.nio.ch.DirectBuffer;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.reflect.Field;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class PingPongMapMain {
public static void main(String... args) throws IOException {
boolean odd;
switch (args.length < 1 ? "usage" : args[0].toLowerCase()) {
case "odd":
odd = true;
break;
case "even":
odd = false;
break;
default:
System.err.println("Usage: java PingPongMain [odd|even]");
return;
}
int runs = 10000000;
long start = 0;
System.out.println("Waiting for the other odd/even");
File counters = new File(System.getProperty("java.io.tmpdir"), "counters.deleteme");
counters.deleteOnExit();
try (FileChannel fc = new RandomAccessFile(counters, "rw").getChannel()) {
MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
long address = ((DirectBuffer) mbb).address();
for (int i = -1; i < runs; i++) {
for (; ; ) {
long value = UNSAFE.getLongVolatile(null, address);
boolean isOdd = (value & 1) != 0;
if (isOdd != odd)
// wait for the other side.
continue;
// make the change atomic, just in case there is more than one odd/even process
if (UNSAFE.compareAndSwapLong(null, address, value, value + 1))
break;
}
if (i == 0) {
System.out.println("Started");
start = System.nanoTime();
}
}
}
System.out.printf("... Finished, average ping/pong took %,d ns%n",
(System.nanoTime() - start) / runs);
}
static final Unsafe UNSAFE;
static {
try {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
UNSAFE = (Unsafe) theUnsafe.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
}
}

当你分别在两个程序，一个输入odd一个输入even，中运行时，可以看到两个进程都是通过持久化共享内存交换数据的。
在每个程序中，将相同的磁盘缓存映射到进程中。内存中实际上只有一份文件的副本存在。这意味着内存可以共享，前提是你使用线程安全的操作，比如volatile变量和CAS操作。（译注：CAS Compare and Swap 无锁算法）
在两个进程之间有83ns的往返时间。当考虑到System V IPC（进程间通信）大约需要2500ns，而且用IPC volatile替代persisted内存，算是相当快的了。
Unsafe适合在工作中使用吗？
个人不建议直接使用Unsafe。它远比原生的Java开发所需要的测试多。基于这个原因建议还是使用经过测试的库。如果你只是想自己用Unsafe，建议你最好在一个独立的类库中进行全面的测试。这限制了Unsafe在你的应用程序中的使用方式，但会给你一个更安全的Unsafe。
总结
Unsafe在Java中是很有趣的一个存在，你可以一个人在家里随便玩玩。它也有一些工作的应用程序特别是在写底层库的时候，但总的来说，使用经过测试的Unsafe库比直接用要好。

8. Java为什么会引入及如何使用Unsafe

sun.misc.Unsafe至少从2004年Java1.4开始就存在于Java中了。在Java9中，为了提高JVM的可维护性，Unsafe和许多其他的东西一起都被作为内部使用类隐藏起来了。但是究竟是什么取代Unsafe不得而知，个人推测会有不止一样来取代它

9. C#代码unsafe public static extern string shibie1(byte* ptr, int w, int h);转成java代码应该怎么转

你肯定是C# 代码，C#有指针了？？
PS：unsafe 的 还有地址操作，还是按功能重新吧。否则，不涉及地址操作，直接按代码用 java 类重写。