本文目录
- java nio和数组有什么区别
- java ByteBuffer allocateDirect分配的是物理内存吗
- 怎么回收bytebuffer.allocatedirect
- 一道java题关于ByteBuffer.allocate()和ByteBuffer.allocateDirect
- JVM报错“Failed to write core dump“是什么问题，如何解决
- java的aio中AsynchronousSocketChannel.read第一个参数有什么用
- java byte[] 和ByteBuffer作为中间缓存各有什么特点
- 我用JAVA NIO 来复制文件，但没有发现和传统的流的方式来操作有明显的优势，为什么呢
- 如何引入java.nio.heapbytebuffer
- glsl 顶点着色器 能实现波浪吗
java nio和数组有什么区别
一. 介绍NIO
NIO包（java.nio.*）引入了四个关键的抽象数据类型，它们共同解决传统的I/O类中的一些问题。
1． Buffer：它是包含数据且用于读写的线形表结构。其中还提供了一个特殊类用于内存映射文件的I/O操作。
2． Charset：它提供Unicode字符串影射到字节序列以及逆影射的操作。
3． Channels：包含socket，file和pipe三种管道，它实际上是双向交流的通道。
4． Selector：它将多元异步I/O操作集中到一个或多个线程中（它可以被看成是Unix中select（）函数或Win32中WaitForSingleEvent（）函数的面向对象版本）。
二. 回顾传统
在介绍NIO之前，有必要了解传统的I/O操作的方式。以网络应用为例，传统方式需要监听一个ServerSocket，接受请求的连接为其提供服务（服务通常包括了处理请求并发送响应）图一是服务器的生命周期图，其中标有粗黑线条的部分表明会发生I/O阻塞。
图一
可以分析创建服务器的每个具体步骤。首先创建ServerSocket
ServerSocket server=new ServerSocket（10000）；
然后接受新的连接请求
Socket newConnection=server.accept（）；
对于accept方法的调用将造成阻塞，直到ServerSocket接受到一个连接请求为止。一旦连接请求被接受，服务器可以读客户socket中的请求。
InputStream in = newConnection.getInputStream();
InputStreamReader reader = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(reader);
Request request = new Request();
while(!request.isComplete()) {
String line = buffer.readLine();
request.addLine(line);
}
这样的操作有两个问题，首先BufferedReader类的readLine（）方法在其缓冲区未满时会造成线程阻塞，只有一定数据填满了缓冲区或者客户关闭了套接字，方法才会返回。其次，它回产生大量的垃圾，BufferedReader创建了缓冲区来从客户套接字读入数据，但是同样创建了一些字符串存储这些数据。虽然BufferedReader内部提供了StringBuffer处理这一问题，但是所有的String很快变成了垃圾需要回收。
同样的问题在发送响应代码中也存在
Response response = request.generateResponse();
OutputStream out = newConnection.getOutputStream();
InputStream in = response.getInputStream()；
int ch；
while(-1 != (ch = in.read())) {
out.write(ch);
}
newConnection.close();
类似的，读写操作被阻塞而且向流中一次写入一个字符会造成效率低下，所以应该使用缓冲区，但是一旦使用缓冲，流又会产生更多的垃圾。
传统的解决方法
通常在Java中处理阻塞I/O要用到线程（大量的线程）。一般是实现一个线程池用来处理请求，如图二
图二
线程使得服务器可以处理多个连接，但是它们也同样引发了许多问题。每个线程拥有自己的栈空间并且占用一些CPU时间，耗费很大，而且很多时间是浪费在阻塞的I/O操作上，没有有效的利用CPU。
三. 新I/O
1． Buffer
传统的I/O不断的浪费对象资源（通常是String）。新I/O通过使用Buffer读写数据避免了资源浪费。Buffer对象是线性的，有序的数据集合，它根据其类别只包含唯一的数据类型。
java.nio.Buffer 类描述
java.nio.ByteBuffer 包含字节类型。 可以从ReadableByteChannel中读在 WritableByteChannel中写
java.nio.MappedByteBuffer 包含字节类型，直接在内存某一区域映射
java.nio.CharBuffer 包含字符类型，不能写入通道
java.nio.DoubleBuffer 包含double类型，不能写入通道
java.nio.FloatBuffer 包含float类型
java.nio.IntBuffer 包含int类型
java.nio.LongBuffer 包含long类型
java.nio.ShortBuffer 包含short类型
可以通过调用allocate(int capacity)方法或者allocateDirect(int capacity)方法分配一个Buffer。特别的，你可以创建MappedBytesBuffer通过调用FileChannel.map(int mode,long position,int size)。直接（direct）buffer在内存中分配一段连续的块并使用本地访问方法读写数据。非直接(nondirect)buffer通过使用Java中的数组访问代码读写数据。有时候必须使用非直接缓冲例如使用任何的wrap方法（如ByteBuffer.wrap(byte)）在Java数组基础上创建buffer。
2． 字符编码
向ByteBuffer中存放数据涉及到两个问题：字节的顺序和字符转换。ByteBuffer内部通过ByteOrder类处理了字节顺序问题，但是并没有处理字符转换。事实上，ByteBuffer没有提供方法读写String。
Java.nio.charset.Charset处理了字符转换问题。它通过构造CharsetEncoder和CharsetDecoder将字符序列转换成字节和逆转换。
3． 通道(Channel)
你可能注意到现有的java.io类中没有一个能够读写Buffer类型，所以NIO中提供了Channel类来读写Buffer。通道可以认为是一种连接，可以是到特定设备，程序或者是网络的连接。通道的类等级结构图如下
图三
图中ReadableByteChannel和WritableByteChannel分别用于读写。
GatheringByteChannel可以从使用一次将多个Buffer中的数据写入通道，相反的，ScatteringByteChannel则可以一次将数据从通道读入多个Buffer中。你还可以设置通道使其为阻塞或非阻塞I/O操作服务。
为了使通道能够同传统I/O类相容，Channel类提供了静态方法创建Stream或Reader
4． Selector
在过去的阻塞I/O中，我们一般知道什么时候可以向stream中读或写，因为方法调用直到stream准备好时返回。但是使用非阻塞通道，我们需要一些方法来知道什么时候通道准备好了。在NIO包中，设计Selector就是为了这个目的。SelectableChannel可以注册特定的事件，而不是在事件发生时通知应用，通道跟踪事件。然后，当应用调用Selector上的任意一个selection方法时，它查看注册了的通道看是否有任何感兴趣的事件发生。图四是selector和两个已注册的通道的例子
图四
并不是所有的通道都支持所有的操作。SelectionKey类定义了所有可能的操作位，将要用两次。首先，当应用调用SelectableChannel.register(Selector sel,int op)方法注册通道时，它将所需操作作为第二个参数传递到方法中。然后，一旦SelectionKey被选中了，SelectionKey的readyOps()方法返回所有通道支持操作的数位的和。SelectableChannel的validOps方法返回每个通道允许的操作。注册通道不支持的操作将引发IllegalArgumentException异常。下表列出了SelectableChannel子类所支持的操作。
ServerSocketChannel OP_ACCEPT
SocketChannel OP_CONNECT, OP_READ, OP_WRITE
DatagramChannel OP_READ, OP_WRITE
Pipe.SourceChannel OP_READ
Pipe.SinkChannel OP_WRITE
四. 举例说明
1． 简单网页内容下载
这个例子非常简单，类SocketChannelReader使用SocketChannel来下载特定网页的HTML内容。
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.net.InetSocketAddress;
import java.io.IOException;
public class SocketChannelReader{
private Charset charset=Charset.forName(“UTF-8“);//创建UTF-8字符集
private SocketChannel channel;
public void getHTMLContent(){
try{
connect();
sendRequest();
readResponse();
}catch(IOException e){
System.err.println(e.toString());
}finally{
if(channel!=null){
try{
channel.close();
}catch(IOException e){}
}
}
}
private void connect()throws IOException{//连接到CSDN
InetSocketAddress socketAddress=
new InetSocketAddress(“*/
SelectionKey acceptKey = ssc.register(acceptSelector,
SelectionKey.OP_ACCEPT);
int keysAdded = 0;
/*select方法在任何上面注册了的操作发生时返回*/
while ((keysAdded = acceptSelector.select()) 》 0) {
// 某客户已经准备好可以进行I/O操作了，获取其ready键集合
Set readyKeys = acceptSelector.selectedKeys();
Iterator i = readyKeys.iterator();
// 遍历ready键集合，并处理加法请求
while (i.hasNext()) {
SelectionKey sk = (SelectionKey)i.next();
i.remove();
ServerSocketChannel nextReady =
(ServerSocketChannel)sk.channel();
// 接受加法请求并处理它
_clientSocket = nextReady.accept().socket();
processRequest();
_clientSocket.close();
}
}
}
参考资料
1． 《Master Merlin’s new I/O classes》 From 《http://www.javawordl.com/》
2． J2SE1.4.2 API Specification From 《http://java.sun.com/》
3． 《Working with SocketChannels》 From 《http://developer.java.sun.com/developer》
4. NIO Examples From 《http://java.sun.com/》
java ByteBuffer allocateDirect分配的是物理内存吗
当然是的啦，下面粘贴复制：
在Java中当我们要对数据进行更底层的操作时，通常是操作数据的字节（byte）形式，这时常常会用到ByteBuffer这样一个类。ByteBuffer提供了两种静态实例方式：
Java代码
public static ByteBuffer allocate(int capacity)
public static ByteBuffer allocateDirect(int capacity)
为什么要提供两种方式呢？这与Java的内存使用机制有关。第一种分配方式产生的内存开销是在JVM中的，而第二种的分配方式产生的开销在JVM之外，以就是系统级的内存分配。-数组
怎么回收bytebuffer.allocatedirect
一、首先是JavaDocument：
直接与非直接缓冲区
字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
直接字节缓冲区可以通过调用此类的 allocateDirect 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。
二、allocateDirect
public static ByteBuffer allocateDirect(int capacity)分配新的直接字节缓冲区。新缓冲区的位置将为零，其界限将为其容量，其标记是不确定的。无论它是否具有底层实现数组，其标记都是不确定的。
参数：
capacity - 新缓冲区的容量，以字节为单位
返回：
新的字节缓冲区
抛出：
IllegalArgumentException - 如果 capacity 为负整数
三、allocate 方法：
分配一个HeapByteBuffer的实例，其底层是byte数组。
在使用ByteBuffer 分配字节数组的时候，要注意使用！
-java
一道java题关于ByteBuffer.allocate()和ByteBuffer.allocateDirect
allocateDirect
public static ByteBuffer allocateDirect(int capacity)分配新的直接字节缓冲区。
新缓冲区的位置将为零，其界限将为其容量，其标记是不确定的。无论它是否具有底层实现数组，其标记都是不确定的。
参数：
capacity - 新缓冲区的容量，以字节为单位
allocate
public static ByteBuffer allocate(int capacity)分配一个新的字节缓冲区。
新缓冲区的位置将为零，其界限将为其容量，其标记是不确定的。它将具有一个底层实现数组，且其 数组偏移量将为零。
参数：
capacity - 新缓冲区的容量，以字节为单位
allocate和allocateDirect方法都做了相同的工作，不同的是allocateDirect方法直接使用操作系统来分配Buffer。因而它将提供更快的访问速度。不幸的是，并非所有的虚拟机都支持这种直接分配的方法。
Sun推荐将以字节为单位的直接型缓冲区allocateDirect用于与大型文件相关并具有较长生命周期的缓冲区。
-数组
JVM报错“Failed to write core dump“是什么问题，如何解决
第一类内存溢出，也是大家认为最多，第一反应认为是的内存溢出，就是堆栈溢出：
那什么样的情况就是堆栈溢出呢？当你看到下面的关键字的时候它就是堆栈溢出了：
java.lang.OutOfMemoryError: ......java heap space.....
也就是当你看到heap相关的时候就肯定是堆栈溢出了，此时如果代码没有问题的情况下，适当调整-Xmx和-Xms是可以避免的，不过一定是代码没有问题的前提，为什么会溢出呢，要么代码有问题，要么访问量太多并且每个访问的时间太长或者数据太多，导致数据释放不掉，因为垃圾回收器是要找到那些是垃圾才能回收，这里它不会认为这些东西是垃圾，自然不会去回收了；主意这个溢出之前，可能系统会提前先报错关键字为：-java
java.lang.OutOfMemoryError:GC over head limit exceeded
这种情况是当系统处于高频的GC状态，而且回收的效果依然不佳的情况，就会开始报这个错误，这种情况一般是产生了很多不可以被释放的对象，有可能是引用使用不当导致，或申请大对象导致，但是java heap space的内存溢出有可能提前不会报这个错误，也就是可能内存就直接不够导致，而不是高频GC.-数组
第二类内存溢出，PermGen的溢出，或者PermGen 满了的提示，你会看到这样的关键字：
关键信息为:
java.lang.OutOfMemoryError: PermGen space
原因：系统的代码非常多或引用的第三方包非常多、或代码中使用了大量的常量、或通过intern注入常量、或者通过动态代码加载等方法，导致常量池的膨胀，虽然JDK 1.5以后可以通过设置对永久带进行回收，但是我们希望的是这个地方是不做GC的，它够用就行，所以一般情况下今年少做类似的操作，所以在面对这种情况常用的手段是：增加-XX:PermSize和-XX:MaxPermSize的大小。-java
第三类内存溢出：在使用ByteBuffer中的allocateDirect()的时候会用到，很多javaNIO的框架中被封装为其他的方法
溢出关键字：
java.lang.OutOfMemoryError: Direct buffer memory
如果你在直接或间接使用了ByteBuffer中的allocateDirect方法的时候，而不做clear的时候就会出现类似的问题，常规的引用程序IO输出存在一个内核态与用户态的转换过程，也就是对应直接内存与非直接内存，如果常规的应用程序你要将一个文件的内容输出到客户端需要通过OS的直接内存转换拷贝到程序的非直接内存（也就是heap中），然后再输出到直接内存由操作系统发送出去，而直接内存就是由OS和应用程序共同管理的，而非直接内存可以直接由应用程序自己控制的内存，jvm垃圾回收不会回收掉直接内存这部分的内存，所以要注意了哦。-数组
如果经常有类似的操作，可以考虑设置参数：-XX:MaxDirectMemorySize
第四类内存溢出错误：
溢出关键字：
java.lang.StackOverflowError
这个参数直接说明一个内容，就是-Xss太小了，我们申请很多局部调用的栈针等内容是存放在用户当前所持有的线程中的，线程在jdk 1.4以前默认是256K，1.5以后是1M，如果报这个错，只能说明-Xss设置得太小，当然有些厂商的JVM不是这个参数，本文仅仅针对Hotspot VM而已；不过在有必要的情况下可以对系统做一些优化，使得-Xss的值是可用的。-java
第五类内存溢出错误：
溢出关键字：
java.lang.OutOfMemoryError: unable to create new native thread
上面第四种溢出错误，已经说明了线程的内存空间，其实线程基本只占用heap以外的内存区域，也就是这个错误说明除了heap以外的区域，无法为线程分配一块内存区域了，这个要么是内存本身就不够，要么heap的空间设置得太大了，导致了剩余的内存已经不多了，而由于线程本身要占用内存，所以就不够用了，说明了原因，如何去修改，不用我多说，你懂的。-数组
第六类内存溢出：
溢出关键字
java.lang.OutOfMemoryError: request {} byte for {}out of swap
这类错误一般是由于地址空间不够而导致。
java的aio中AsynchronousSocketChannel.read第一个参数有什么用
final ByteBuffer buffer = ByteBuffer
.allocateDirect(1024);
// transmitting data
while (asynchronousSocketChannel.read(buffer)
.get() != -1) {
buffer.flip();
}
第一个参数是字符缓冲区对象。
-java
java byte[] 和ByteBuffer作为中间缓存各有什么特点
byteBuffer就是在byte基础上发明的轮子。抽象上高一级，原理一样。
如果用byte能直接实现，用byte是最直接有效的。
bytebuffer主要和NIO配套使用，让自己的代码融入NIO，不一定适用于脱离NIO相关的自制环境。
-数组
我用JAVA NIO 来复制文件，但没有发现和传统的流的方式来操作有明显的优势，为什么呢
好好读读Thinking in java文档，从1.5开始，Java对InputStream/OutputStream 进行了重新改写，用的就是NIO，因此，就算你不显示声明要用NIO，只要你的类继承了InputStream/OutputStream就已经在用NIO了，不信的话这样做
FileChannel channel=new FileInputStream.getChannel();
如果XXStream不用NIO构造，如何返回一个Channel的对象？
-java
如何引入java.nio.heapbytebuffer
heap buffer 和 direct buffer区别
在Java的NIO中，我们一般采用ByteBuffer缓冲区来传输数据，一般情况下我们创建Buffer对象是通过ByteBuffer的两个静态方法：
ByteBuffer.allocate(int capacity);
ByteBuffer.wrap(byte array);
查看JDK的NIO的源代码关于这两个部分：
/**allocate()函数的源码**/
public static ByteBuffer allocate(int capacity) {
if (capacity 《 0)
throw new IllegalArgumentException();
return new HeapByteBuffer(capacity, capacity);
}
/**wrap()函数的源码**/
public static ByteBuffer wrap(byte array) {
return wrap(array, 0, array.length);
}
//
public static ByteBuffer wrap(byte array,
int offset, int length)
{
try {
return new HeapByteBuffer(array, offset, length);
} catch (IllegalArgumentException x) {
throw new IndexOutOfBoundsException();
}
}
我们可以很清楚的发现，这两个方法都是实例化HeapByteBuffer来创建的ByteBuffer对象，也就是heap buffer. 其实除了heap buffer以外还有一种buffer，叫做direct buffer。我们也可以创建这一种buffer，通过ByteBuffer.allocateDirect(int capacity)方法，查看JDK源码如下：
public static ByteBuffer allocateDirect(int capacity) {
return new DirectByteBuffer(capacity);
}
我们发现该函数调用的是DirectByteBuffer(capacity)这个类，这个类就是创建了direct buffer。
-数组
glsl 顶点着色器 能实现波浪吗
设置OpenGL ES环境
创建GLSurfaceView
显示OpenGL图形需要使用GLSurfaceView类像其任何View类意义添加Activity或Fragment通布局xml文件定义或者代码创建实例
本教程我使用GLSurfaceView作唯View我Activity简便我代码创建GLSurfaceView实例并其传入setContentView填充整手机屏幕ActivityonCreate：
protected void onCreate（Bundle savedInstanceState） { super.onCreate（savedInstanceState）； GLSurfaceView view = new GLSurfaceView（this）； setContentView（view）；}
媒体效框架仅仅支持OpenGL ES2.0及版本所setEGLContextClientVersion 传入2；
view.setEGLContextClientVersion（2）；
确保GLSurfaceView仅仅必要候进行渲染我setRenderMode 进行设置：
view.setRenderMode（GLSurfaceView.RENDERMODE_WHEN_DIRTY）；
创建Renderer
Renderer负责渲染GLSurfaceView内容
创建类实现接口GLSurfaceView.Renderer我打算类命名EffectsRenderer添加构造函数并覆写接口抽象：
public class EffectsRenderer implements GLSurfaceView.Renderer { public EffectsRenderer（Context context）{ super（）； } @Override public void onSurfaceCreated（GL10 gl, EGLConfig config） { } @Override public void onSurfaceChanged（GL10 gl, int width, int height） { } @Override public void onDrawFrame（GL10 gl） { }}
Activity调用setRenderer让GLSurfaceView使用我创建Renderer：
view.setRenderer（new EffectsRenderer（this））；
编写Manifest文件
想要发布App谷歌商店AndroidManifest.xml文件添加语句：
确保app能安装支持OpenGL ES2.0设备现OpenGL环境准备完毕
创建OpenGL平面
定义顶点
GLSurfaceView能直接显示张照片照片首先应该转化纹理应用OpenGL square本教程我创建2D平面并且具4顶点简单我使用形现创建新类Square用代表形状
public class Square {}
默认OpenGL系统坐标系原点4角坐标表示：
左角： （-1, -1） 右角：（1, -1） 右角：（1, 1） 左角：（-1, 1）
我使用OpenGL绘制所物体都应该由三角形决定画形我需要两具条公共边三角形意味着些三角形坐标应该：
triangle 1: （-1, -1） （1, -1） （-1, 1） triangle 2: （1, -1） （-1, 1） （1, 1）
创建float数组代表些顶点：
private float vertices = { -1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f,};
square定位纹理需要确定纹理顶点坐标创建另数组表示纹理顶点坐标：
private float textureVertices = { 0f,1f, 1f,1f, 0f,0f, 1f,0f};
创建缓冲区
些坐标数组应该转变缓冲字符（byte buffer）OpenGL使用前接进行定义：
private FloatBuffer verticesBuffer;private FloatBuffer textureBuffer;
initializeBuffers初始化些缓冲区：使用ByteBuffer.allocateDirect创建缓冲区float4字节我需要byte数组度应该float4倍
面使用ByteBuffer.nativeOrder定义底层本平台byte顺序使用asFloatBufferByteBuffer转化FloatBufferFloatBuffer创建我调用putfloat数组放入缓冲区调用position保证我由缓冲区进行读取
private void initializeBuffers（）{ ByteBuffer buff = ByteBuffer.allocateDirect（vertices.length * 4）； buff.order（ByteOrder.nativeOrder（））； verticesBuffer = buff.asFloatBuffer（）； verticesBuffer.put（vertices）； verticesBuffer.position（0）； buff = ByteBuffer.allocateDirect（textureVertices.length * 4）； buff.order（ByteOrder.nativeOrder（））； textureBuffer = buff.asFloatBuffer（）； textureBuffer.put（textureVertices）； textureBuffer.position（0）；}
创建着色器
着色器简单运行GPU每单独顶点C程序本教程我使用两种着色器：顶点着色器片段着色器
顶点着色器代码：
attribute vec4 aPosition; attribute vec2 aTexPosition; varying vec2 vTexPosition; void main（） { gl_Position = aPosition; vTexPosition = aTexPosition; };
片段着色器代码
precision mediump float; uniform. sampler2D uTexture; varying vec2 vTexPosition; void main（） { gl_FragColor = texture2D（uTexture, vTexPosition）； };
解OpenGL段代码说熟悉能理解段代码参考OpenGL documentation
-
-java
