IO学霸2 -- NIO

最新推荐文章于 2022-04-01 15:45:58 发布
最新推荐文章于 2022-04-01 15:45:58 发布
阅读量1.2k 收藏
点赞数
分类专栏： java学霸笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eyeooo/article/details/12872921
版权

11. NIO

JDK1.4的java.nio.*已经加入新的IO类库，目的在于提高速度。实际上旧的IO包已经使用nio重写，即使不显示用nio写代码，速度已经得到提升。

这种速度提升得益于使用的结构接近于操作系统执行IO的方式：通道与缓冲器。

唯一直接与通道交互的缓冲器：ByteBuffer。

产生FileChannel的三个类：FileInputStream, FileOutputStream, RandomAccessFile.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class GetChannel {

	private static final int BSIZE = 1024;
	
	public static void main(String[] args) throws IOException {
		FileChannel fc = new FileOutputStream("data.txt").getChannel();
		fc.write(ByteBuffer.wrap("Some text ".getBytes()));
		fc.close();
		fc = new RandomAccessFile("data.txt","rw").getChannel();
		fc.position(fc.size());
		fc.write(ByteBuffer.wrap("Some more".getBytes()));
		fc.close();
		fc = new FileInputStream("data.txt").getChannel();
		ByteBuffer buff = ByteBuffer.allocate(BSIZE);
		fc.read(buff);
		buff.flip();
		while(buff.hasRemaining()){
			System.out.print((char)buff.get());
		}
	}

}
//*Output:
Some text Some more
*//

文件复制，注意flip()与clear()的使用

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelCopy {
	private static final int BSIZE = 1024;
	public static void main(String[] args) throws IOException {
		if(args.length!=2){
			System.out.println("args shit");
			System.exit(1);
		}
		FileChannel in = new FileInputStream("D:\\javaLD\\workspace_IBM\\IO1\\src\\com\\ld\\tij\\ChannelCopy.java").getChannel(),
		out = new FileOutputStream(args[1]).getChannel();
		ByteBuffer buffer = ByteBuffer.allocate(BSIZE);
		while(in.read(buffer)!=-1){
			buffer.flip();
			out.write(buffer);
			buffer.clear();
		}
		//method 2：改进方法transferTo()/transferFrom() 可以将一个通道与另外一个通道相连
		in.transferTo(0, in.size(), new FileOutputStream("test2.txt").getChannel());
	}

}

11.1 NIO中转换数据 

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;

public class BufferToText {
	private static final int BSIZE = 1024;
	public static void main(String[] args) throws IOException {

		FileChannel fc = new FileOutputStream("data2.txt").getChannel();
		fc.write(ByteBuffer.wrap("Some text".getBytes()));
		fc.close();
		
		fc = new FileInputStream("data2.txt").getChannel();
		ByteBuffer buff = ByteBuffer.allocate(BSIZE);
		fc.read(buff);
		buff.flip();
		System.out.println(buff.asCharBuffer());
		
		buff.rewind();
		String encoding = System.getProperty("file.encoding");
		System.out.println("Decoded using "+encoding+": "+ Charset.forName(encoding).decode(buff));
		
		fc = new FileOutputStream("data2.txt").getChannel();
		fc.write(ByteBuffer.wrap("Some text by utf".getBytes("UTF-16BE")));
		fc.close();
		fc = new FileInputStream("data2.txt").getChannel();
		buff.clear();
		fc.read(buff);
		buff.flip();
		System.out.println(buff.asCharBuffer());
		
		fc = new FileOutputStream("data2.txt").getChannel();
		buff = ByteBuffer.allocate(100);
		buff.asCharBuffer().put("some text as charbuffer");
		fc.write(buff);
		fc.close();
		fc = new FileInputStream("data2.txt").getChannel();
		buff.clear();
		fc.read(buff);
		buff.flip();
		System.out.println(buff.asCharBuffer());
	}

}
//*output:
????
Decoded using GBK: Some text
Some text by utf
some text as charbuffer
*//

打印第一行错误原因是因为既没有编码也没有解码。

第二行有解码

第三行有编码

第四行读写都指定了相应的数据格式

在这个例子基础上，下面是一个对各种数据类型的例子

import java.nio.ByteBuffer;

public class GetData {

	private static final int BSIZE = 1024;
	
	public static void main(String[] args) {
		ByteBuffer bb = ByteBuffer.allocate(BSIZE);
		
		int i =0;
		while(i++<bb.limit()){
			if(bb.get()!=0)
				System.out.println("nonzero");
		}
		System.out.println("i="+i);
		bb.rewind();
		
		bb.asCharBuffer().put("Howdy!");
		char c;
		while((c=bb.getChar())!=0){
			System.out.print(c+" ");
		}
		System.out.println();
		bb.rewind();
		
		bb.asShortBuffer().put((short)471142);
		System.out.println(bb.getShort());
		bb.rewind();
		
		bb.asIntBuffer().put(99471142);
		System.out.println(bb.getInt());
		bb.rewind();
		
		bb.asLongBuffer().put(99471142);
		System.out.println(bb.getLong());
		bb.rewind();
		
		bb.asFloatBuffer().put(99471142);
		System.out.println(bb.getFloat());
		bb.rewind();
		
		bb.asDoubleBuffer().put(99471142);
		System.out.println(bb.getDouble());
		bb.rewind();
		
	}

}
//*Output:
i=1025
H o w d y ! 
12390
99471142
99471142
9.9471144E7
9.9471142E7
*//

11.2 视图缓冲器

通过某个特定的基本数据类型的view查看其底层的ByteBuffer。ByteBuffer依然是实际保存数据的地方，并支持前面的view，所以对view任何修改都会映射成为修改后ByteBuffer中的数据。

import java.nio.ByteBuffer;
import java.nio.IntBuffer;

public class IntBufferDemo {
	private static final int BSIZE = 1024;
	public static void main(String[] args) {
		ByteBuffer bb = ByteBuffer.allocate(BSIZE);
		IntBuffer ib = bb.asIntBuffer();
		ib.put(new int[]{11,42,47,99,143,811,1016});
		System.out.println("ib3:"+ib.get(3));
		ib.put(3, 1811);
		ib.flip();
		while(ib.hasRemaining()){
			System.out.println(ib.get());
		}
	}

}
//*Output:
ib3:99
11
42
47
1811
143
811
1016
*//

在同一个ByteBuffer建立不同的view buffer，将同一个字节序列翻译成short, int, float, long, double. 

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public class ViewBuffers {

	public static void main(String[] args) {
		ByteBuffer bb = ByteBuffer.wrap(new byte[]{0,0,0,0,0,0,0,'a'});
		bb.rewind();
		System.out.println("Byte Buffer ");
		while(bb.hasRemaining()){
			System.out.print(bb.position()+"->"+bb.get()+", ");
		}
		System.out.println();
		
		CharBuffer cb = ((ByteBuffer)bb.rewind()).asCharBuffer();
		System.out.println("Char Buffer");
		while(cb.hasRemaining()){
			System.out.print(cb.position()+"->"+cb.get()+", ");
		}
		System.out.println();
		
		FloatBuffer fb = ((ByteBuffer)bb.rewind()).asFloatBuffer();
		System.out.println("Float Buffer");
		while(fb.hasRemaining()){
			System.out.print(fb.position()+"->"+fb.get()+", ");
		}
		System.out.println();
		
		IntBuffer ib = ((ByteBuffer)bb.rewind()).asIntBuffer();
		System.out.println("Int Buffer");
		while(ib.hasRemaining()){
			System.out.print(ib.position()+"->"+ib.get()+", ");
		}
		System.out.println();
		
		LongBuffer lb = ((ByteBuffer)bb.rewind()).asLongBuffer();
		System.out.println("Long Buffer");
		while(lb.hasRemaining()){
			System.out.print(lb.position()+"->"+lb.get()+", ");
		}
		System.out.println();
		
		ShortBuffer sb = ((ByteBuffer)bb.rewind()).asShortBuffer();
		System.out.println("Short Buffer");
		while(sb.hasRemaining()){
			System.out.print(sb.position()+"->"+sb.get()+", ");
		}
		System.out.println();
		
		DoubleBuffer db = ((ByteBuffer)bb.rewind()).asDoubleBuffer();
		System.out.println("Double Buffer");
		while(db.hasRemaining()){
			System.out.print(db.position()+"->"+db.get()+", ");
		}
		System.out.println();
		
	}

}
//*output:
Byte Buffer 
0->0, 1->0, 2->0, 3->0, 4->0, 5->0, 6->0, 7->97, 
Char Buffer
0-> , 1->, 2-> , 3-> a,
Float Buffer
0->0.0, 1->1.36E-43, 
Int Buffer
0->0, 1->97, 
Long Buffer
0->97, 
Short Buffer
0->0, 1->0, 2->0, 3->97, 
Double Buffer
0->4.8E-322, 
*//
ByteBuffer是8字节数组产生，然后通过不同的基本类型view buffer显示出来，如下图：



11.2.1字节存放次序（二进制）

big endian 高位优先：将最重要的字节存放在地址最低的存储单元。

little endian 低位优先：讲最重要的字节存放在地址最高的存储单元。

ByteBuffer以高位优先存储数据，网上传送也常用此方式。

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;

public class Endians {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String s = "abcdef";
		ByteBuffer bb = ByteBuffer.wrap(new byte[12]);
		bb.asCharBuffer().put(s);
		System.out.println(Arrays.toString(bb.array()));
		bb.rewind();
		bb.order(ByteOrder.BIG_ENDIAN);
		bb.asCharBuffer().put(s);
		System.out.println(Arrays.toString(bb.array()));
		bb.rewind();
		bb.order(ByteOrder.LITTLE_ENDIAN);
		bb.asCharBuffer().put(s);
		System.out.println(Arrays.toString(bb.array()));
	}

}
//*Output:
[0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102]
[0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102]
[97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0]
*//



11.2.2 深入缓冲区

Buffer由数据和四个索引组成：mark, position, limit, capacity。

capacity(): 返回缓冲区容量;

clear(): 清空缓冲区，position=0, limit=capacity();

flip(): limit=position, position=0;

limit(): 返回limit值;

limit(int lim): 设置limit值;

mark(): mark=position;

position(): 返回position值;

position(int pos): 设置position值;

remaining(): 返回(limit - position);

hasRemaining(): 如果存在position和limit之间元素(limit-position>0?)，则返回ture;

reset(): position=mark.



例子：交换缓冲器中相邻的字符

import java.nio.ByteBuffer;
import java.nio.CharBuffer;

public class UsingBuffers {

	private static void symmetricScramble(CharBuffer buffer){
		while(buffer.hasRemaining()){
			buffer.mark();
			char c1 = buffer.get();
			char c2 = buffer.get();
			buffer.reset();
			buffer.put(c2).put(c1);
		}
	}
	
	
	public static void main(String[] args) {
		char[] data = "UsingBuffers".toCharArray();
		ByteBuffer bb = ByteBuffer.allocate(data.length*2);
		CharBuffer cb = bb.asCharBuffer();
		cb.put(data);
		System.out.println(cb.rewind());
		symmetricScramble(cb);
		System.out.println(cb.rewind());
		symmetricScramble(cb);
		System.out.println(cb.rewind());
	}

}
//*Output:
UsingBuffers
sUniBgfuefsr
UsingBuffers
*//

11.2.3 内存映射文件

内存映射文件用于创建和修改因为太大不能放入内存的文件，使用这种方式，我们可以假定这个文件都放在内存中，而且可以完全把它当做巨大的数组来访问。

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class LargeMappedFiles {

	static int length = 0x8FFFFFF; //128MB
	
	public static void main(String[] args) throws IOException, Exception {
		// TODO Auto-generated method stub
		MappedByteBuffer out 
			= new RandomAccessFile("test.dat","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, length);
		for(int i=0;i<length;i++){
			out.put((byte)'x');
		}
		System.out.println("Finished writing");
		for(int i=length/2;i<length/2+60;i++){
			System.out.print((char)out.get(i));
		}
	}

}
//*Output:
Finished writing
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
*//

11.2.4 加锁 

import java.io.FileOutputStream;
import java.nio.channels.FileLock;
import java.util.concurrent.TimeUnit;

public class FileLocking {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		FileOutputStream fos = new FileOutputStream("file.txt");
		FileLock fl = fos.getChannel().tryLock();
		if(fl!=null){
			System.out.println("Locked File");
			TimeUnit.MILLISECONDS.sleep(1000);
			fl.release();
			System.out.println("Released Lock");
		}
		fos.close();
	}

}
//*Output
Locked File
Released Lock
*//
这里是对整个文件加锁，tryLock()是非阻塞式的，它设法获得锁，否则直接在方法中返回。lock()是阻塞式，阻塞进程直至可以获得锁，或者调用lock()线程中断，或者lock()的通道关闭，FileLock.release()可以释放锁。

11.2.5 部分加锁

tryLock(long position, long size, boolean shared) / lock(long position, long size, boolean shared)

无参数加锁根据文件大小变化而变化，固定大小加锁不会随着文件变化变化，如果获得一段区域加锁(position~position+size)，当文件增大时候，position+size以外的部分将不会被锁定。

对于独占锁或者共享锁由底层的操作系统所决定。如果操作系统不支持共享锁并为每一个请求都创建一个锁，那么它就是独占锁，FileLock.isShared()可以查询。

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;

public class LockingMappedFiles {

	static final int LENGTH = 0x8FFFFFF;//128MB
	static FileChannel fc;
	
	public static void main(String[] args) throws IOException {
		fc = new RandomAccessFile("test.dat", "rw").getChannel();
		MappedByteBuffer out = fc.map(FileChannel.MapMode.READ_WRITE, 0, LENGTH);
		for(int i=0;i<LENGTH;i++){
			out.put((byte)'x');
		}
		new LockAndModify(out,0,0+LENGTH/3);
		new LockAndModify(out,LENGTH/2,LENGTH/2+LENGTH/4);
		
	}
	private static class LockAndModify extends Thread{
		private ByteBuffer buff;
		private int start, end;
		LockAndModify(ByteBuffer mbb, int start, int end){
			this.start=start;
			this.end=end;
			mbb.limit(end);
			mbb.position(start);
			buff = mbb.slice();
			start();
		}
		@Override
		public void run() {
			try {
				FileLock fl = fc.lock(start, end, false);
				System.out.println("Locked: "+start+" to "+end);
				while(buff.position()<buff.limit()-1){
					buff.put((byte)(buff.get()+1));
				}
					fl.release();
					System.out.println("Released: "+start+" to "+end);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		
	}

}
//*Output
Locked: 0 to 50331647
Locked: 75497471 to 113246206
Released: 75497471 to 113246206
Released: 0 to 50331647
*//

finished nio，IO未完持续~:)






eyeooo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot中接口幂等性实现方案-自定义注解+Redis+拦截器实现防止订单重复提交
BADAO_LIUMANG_QIZHI的博客
07-25 1767
以下接口幂等性的实现方式与上面博客类似，可参考。
flume数据丢失与重复_Flume基础学习
weixin_39702335的博客
12-26 794
Flume是一款非常优秀的日志采集工具。支持多种形式的日志采集，作为apache的顶级开源项目，Flume再大数据方面具有广泛的应用首先需要在Flume的解压目录中conf文件夹中将flume-env.sh.templete更改未flume.env.sh并修改jdk的位置Source我们可以从Avro，NetCat。Http,TailDir。我们在Java开发中通常都是使用的log4j等日志工具进...
Flume的使用问题及解决方案
北京小辉
04-17 4121
在使用flume-ng时，踩了很多坑，现在来说一下，希望大家绕过坑，到达熟练使用flume的目的 第一坑：不能正确解码文件，造成不能正确的重命名文件，抛出bug后，之后所有文件都不可以被flume收集，是一个比较严重的错，引起原因是flume使用NIO方式读取文件，将读取的文件以UTF-8的编码读取，在linux状态下，默认是按照GBK编码方式存储文件，所以读取时就会遇到字符长度不够问题，解决办
ByteBuffer clear(), flip(), rewind(), remaining(), mark(), reset()
mlnotes
08-01 2754
ByteBuffer类是java.nio中的一个缓冲区类对于ByteBuffer而言，有四个属性 position, limit, mark, capacity0 ByteBuffer实例的方法ByteBuffer方法准备Buffer以实现结果值PositionLimitMarkByteBuffer clear()将数据read()/put() 进缓冲区0capacity未定义ByteBuffer
io nio nio2
weixin_43740680的博客
11-22 144
java IO、NIO、AIO详解 </h1> <div class="clear"></div> <div class="postBody"> 联系QQ：972455766，欢迎大家加QQ一起讨论关于开发相关的问题！目录概述一、IO流（同步、阻塞）二、NIO（同步、非阻塞）三、NIO2(异步、非阻塞) 正文 ...
IO流（二）Java的NIO
q66562636的博客
04-01 1413
1 NIO介绍 Java NIO 全称java non-blocking IO ，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的。 NIO有三大核心部分：Channel（通道），Buffer（缓冲区），Selector（选择器） NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。 Java NIO
Introduction-to-Java-IO.rar_Java IO Tutorial
09-19
这个教程“Introduction-to-Java-IO”旨在深入理解Java IO系统，包括它的设计原理、使用方法，以及对Java New IO（NIO）的介绍。Java IO API提供了一套丰富的类和接口，使得开发者可以有效地读取、写入数据，无论是...
明明白白学Java大学霸
11-19
7. **Java标准库API**：熟悉常用的Java类库，如IO、NIO、XML解析、网络编程等，这些API极大地扩展了Java的功能。 8. **JVM内部原理**：了解Java虚拟机的工作机制，包括类加载、内存管理、垃圾回收等，有助于优化...
非阻塞IO完成版.rar_阻塞IO_非阻塞_非阻塞io
09-15
在这个名为"非阻塞IO完成版.rar"的压缩包中，我们似乎有一个项目，它实现了“剪刀石头布”游戏的功能，使用了非阻塞I/O技术，并且开发环境是NetBeans IDE。NetBeans是一款流行的开源集成开发环境，支持多种编程语言...
qq-java.rar_QQ_java qq_java类似QQ_qq聊天系统java
09-19
考虑到实时性，可能还会使用到多线程或者异步IO（NIO）以提高性能。 数据库设计是另一个关键部分。在类似QQ的聊天系统中，需要存储用户信息、好友关系、聊天记录等。数据库表结构设计应该清晰且高效，如用户表...
java容器学习
eyeooo的狗窝
10-16 1373
1.Set Set(interface): 存入Set的每个元素是唯一的，Set中不存在重复元素，加入Set的元素必须定义equals()方法一确保对象的唯一性，Set接口不保证维护元素的次序。 HashSet（默认）: 快速查找，存入元素必须定义hashCode() TreeSet : 保持次序，底层树结构，提取有序序列需要实现Comparable接口。 LinkedHashSet:  
IO学霸3 -- Serializable
eyeooo的狗窝
10-21 1114
1. 压缩 CheckedInputStream: GetCheckSum()为任何InputStream()产生校验和。 CheckOutputStream: GetCheckSum()为任何OutputStream产生校验和。 DeflaterOutputStream: 压缩类的基类。 ZipOutputStream: 一个DeflaterOutputStream，用于将数据压缩成Zi
短期java学习计划
eyeooo的狗窝
10-16 1097
1.容器进阶，equals与hashCode原理。 2.IO进阶，Nio与缓冲。 3.深入并发。 4.网络与TCP/IP，结合IO与并发深入学习。 5.内存与JVM，java内存机制，review计算机原理，JVM启动与垃圾回收。 6.数据结构与算法，数据结构（大学那本教材）
IO学霸
eyeooo的狗窝
10-19 995
学习IO，有必要了解一下Decorator装饰器模式，该模式在IO设计中大量被使用： http://blog.csdn.net/eyeooo/article/details/12870867 1.InputStream 类 说明 构造器参数 ByteArrayInputStream 允许将内存的缓冲区当做InputStream 缓冲区，字节从
Mali_Texture_Compression_Tool_v4_Windows_x64.zip
08-30
Mali_Texture_Compression_Tool_v4_Windows_x64.zip
高分项目-卡卡汽车 获取用户 设备信息小程序源码（优秀毕业设计源码）.zip
08-30
1. 精选系统小程序代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：java，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
基于Java的图书馆管理系统代码.rar
08-30
一键三连加关注私信up获取源码无偿分享群，以下为福利链接：https://pan.baidu.com/s/1niFL_7h0KhdJSW7r0XdtDw?pwd=1234 提取码：1234 基于springboot的XXXX管理系统，可以用于计算机专业毕设和课设使用 开发语言：Java 开发软件：eclipse/myeclipse/idea 框架：ssm JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 Maven包：Maven3.3.9 浏览器：谷歌浏览器 管理员账号：admin 管理员密码：admin 配置环境安装包： Java配置环境链接：https://cloud.189.cn/t/baeQZrAjEvyy （访问码：pfd5） 后台路径地址：localhost:8080/项目名称/admin/dist/index.html 前台路径地址：localhost:8080/项目名称/front/dist/inde
免费prometheus Mac 版本安装包
最新发布
08-30
Prometheus是一个流行的开源监控和告警工具，特别适合于云原生环境和Kubernetes集群的监控。以下是Prometheus的详细描述： 一、概述 Prometheus是一个基于时序数据库的开源服务监控系统和时序数据库，其提供了通用的数据模型和快捷数据采集、存储和查询接口。自2012年启动以来，许多公司和组织都采用了Prometheus，该项目拥有非常活跃的开发人员和用户社区。Prometheus于2016年加入云原生计算基金会，成为继Kubernetes之后的第二个托管项目。 二、主要特性 多维数据模型：Prometheus的数据模型是基于时间序列的，每个时间序列由度量名称（metric name）和一系列键值对（key-value pairs，也称为标签labels）唯一标识。这种模型允许对数据进行多维度的查询和聚合。 PromQL查询语言：Prometheus提供了一个功能强大的查询语言PromQL（Prometheus Query Language），用户可以使用这个语言对收集到的时序数据进行查询和分析。 高效的数据采集和存储：Prometheus通过HTTP协议周
深入理解Java IO、NIO和NIO.2
"Java IO, NIO 和 NIO.2 是Java平台中处理输入/输出操作的重要组件。本文档深入探讨了这些技术，包括它们的工作原理、优缺点以及如何在实际应用中使用它们。作者Jeff Friesen通过本书提供了一个全面的理解框架，帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值