实时搜索: nio为什么不阻塞

nio为什么不阻塞

484条评论 5408人喜欢 5293次阅读 577人点赞
我知道读写是通过channel操作的,而且读写只能获取当时可用的数据,没有可用数据,就返回。线程可以干别的事。

我想问的是,它怎么获取的当时的可用数据,当之后有数据可用之后,buffer里面又是怎么有的数据。 , 现在的通讯基本上都是用NIO的非堵塞模式来与服务器通讯发送消息包,socketchannel发送数据包时,并没有等待服务器的恢复就会返回,无法判断该条消息是否发送成功,服务器是否收到?作为实时通讯的工具,这样很不好。对NIO socketchannel比较熟悉的高手,有没有好的解决方案,希望指点下! , 请问如何测试程序是否实现了非阻塞?java.nio的Serv...

java nio底层如何实现非阻塞?: 楼主,应该看看C/C++中的异步socket ———如果没有记错,应该是多线程检测

NIO Socketchannel 如何判断发包是否成功?(非堵塞模式): 这个没用过,如果你用TCP的话,会有状态的

请问如何测试程序是否实现了非阻塞?java.nio的ServerSocketChannel一次可以同时接收多个SocketChannel吗?: windows下面socket非组赛其实也就是winsock api的调用而已,比如我用的delphi:

var
addr : TSockAddr;
sock : TSocket;

sock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
addr.sin_family := AF_INET;
addr.sin_port := htons(5678);
addr.sin_addr.S_addr := htonl(INADDR_ANY);
bind( m_sock, @addr, sizeof(SOCKADDR) );

WSAAsyncSelect( m_sock, Handle, WM_SOCKET, FD_ACCEPT or FD_CLOSE ); // 这就是组赛了

listen( m_sock, 5 );
....

ftpclient 用的是nio还是io: nio是new io的简称,从jdk1.4就被引入了。现在的jdk已经到了1.6了,可以说不是什么新东西了。但其中的一些思想值得我来研究。这两天,我研究了下其中的套接字部分,有一些心得,在此分享。
首先先分析下:为什么要nio套接字?
nio的主要作用就是用来解决速度差异的。举个例子:计算机处理的速度,和用户按键盘的速度。这两者的速度相差悬殊。如果按照经典的方法:一个用户设定一个线程,专门等待用户的输入,无形中就造成了严重的资源浪费:每一个线程都需要珍贵的cpu时间片,由于速度差异造成了在这个交互线程中的cpu都用来等待。
nio套接字是怎么做到的?
其实,其中的思想很简单:轮询。一个线程轮询多个input;传统的方式是:有n个客户端就要有n个服务线程+一个监听线程,现在采取这种凡是,可以仅仅使用1个线程来代替n个服务线程以此来解决。
具体应用例子:
在ftp的控制连接中,因为只有少量的字符命令进行传输,所以可以考虑利用这种轮询的方式实现,以节省资源。

-----------------------------------------------------
Java中的阻塞和非阻塞IO包各自的优劣思考
NIO 设计背后的基石:反应器模式,用于事件多路分离和分派的体系结构模式。

反应器(Reactor):用于事件多路分离和分派的体系结构模式

通常的,对一个文件描述符指定的文件或设备, 有两种工作方式: 阻塞 与非阻塞 。所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待 状态, 直到有东西可读或者可写为止。而对于非阻塞状态, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待 。

一种常用做法是:每建立一个Socket连接时,同时创建一个新线程对该Socket进行单独通信(采用阻塞的方式通信)。这种方式具有很高的响应速度,并且控制起来也很简单,在连接数较少的时候非常有效,但是如果对每一个连接都产生一个线程的无疑是对系统资源的一种浪费,如果连接数较多将会出现资源不足的情况。

另一种较高效的做法是:服务器端保存一个Socket连接列表,然后对这个列表进行轮询,如果发现某个Socket端口上有数据可读时(读就绪),则调用该socket连接的相应读操作;如果发现某个 Socket端口上有数据可写时(写就绪),则调用该socket连接的相应写操作;如果某个端口的Socket连接已经中断,则调用相应的析构方法关闭该端口。这样能充分利用服务器资源,效率得到了很大提高。

传统的阻塞式IO,每个连接必须要开一个线程来处理,并且没处理完线程不能退出。

非阻塞式IO,由于基于反应器模式,用于事件多路分离和分派的体系结构模式,所以可以利用线程池来处理。事件来了就处理,处理完了就把线程归还。而传统阻塞方式不能使用线程池来处理,假设当前有10000个连接,非阻塞方式可能用1000个线程的线程池就搞定了,而传统阻塞方式就需要开10000个来处理。如果连接数较多将会出现资源不足的情况。非阻塞的核心优势就在这里。

为什么会这样,下面就对他们做进一步细致具体的分析:

首先,我们来分析传统阻塞式IO的瓶颈在哪里。在连接数不多的情况下,传统IO编写容易方便使用。但是随着连接数的增多,问题传统IO就不行了。因为前面说过,传统IO处理每个连接都要消耗 一个线程,而程序的效率当线程数不多时是随着线程数的增加而增加,但是到一定的数量之后,是随着线程数的增加而减少。这里我们得出结论,传统阻塞式IO的瓶颈在于不能处理过多的连接。

然后,非阻塞式IO的出现的目的就是为了解决这个瓶颈。而非阻塞式IO是怎么实现的呢?非阻塞IO处理连接的线程数和连接数没有联系,也就是说处理10000个连接非阻塞IO不需要10000个线程,你可以用1000个也可以用2000个线程来处理。因为非阻塞IO处理连接是异步的。当某个连接发送请求到服务器,服务器把这个连接请求当作一个请求"事件",并把这个"事件"分配给相应的函数处理。我们可以把这个处理函数放到线程中去执行,执行完就把线程归还。这样一个线程就可以异步的处理多个事件。而阻塞式IO的线程的大部分时间都浪费在等待请求上了。

android阻塞socket和nio谁更省电: /**
* 通过NIO方式进行socket链接
* @author He Zhongqiu
*
*/
public class TCPClient {
/** 信道选择器 */
private Selector mSelector;

/** 服务器通信的信道 */
private SocketChannel mChannel;

/** 远端服务器ip地址 */
private String mRemoteIp;

/** 远端服务器端口 */
private int mPort;

/** 是否加载过的标识 */
private boolean mIsInit = false;

/** 单键实例 */
private static TCPClient gTcp;

private TCPClientEventListener mEventListener;

/** 默认链接超时时间 */
public static final int TIME_OUT = 10000;

/** 读取buff的大小 */
public static final int READ_BUFF_SIZE = 1024;

/** 消息流的格式 */
public static final String BUFF_FORMAT = "utf-8";

public static synchronized TCPClient instance() {
if ( gTcp == null ) {
gTcp = new TCPClient();
}
return gTcp;
}

private TCPClient() {

}

/**
* 链接远端地址
* @param remoteIp
* @param port
* @param TCPClientEventListener
* @return
*/
public void connect( String remoteIp, int port, TCPClientEventListener tcel ) {
mRemoteIp = remoteIp;
mPort = port;
mEventListener = tcel;
connect();
}

/**
* 链接远端地址
* @param remoteIp
* @param port
* @return
*/
public void connect( String remoteIp, int port ) {
connect(remoteIp,port,null);
}

private void connect() {
//需要在子线程下进行链接
MyConnectRunnable connect = new MyConnectRunnable();
new Thread(connect).start();
}

/**
* 发送字符
* @param msg
* @return
*/
public boolean sendMsg(String msg) {
boolean bRes = false;
try {
bRes = sendMsg(msg.getBytes(BUFF_FORMAT));
} catch ( Exception e ) {
e.printStackTrace();
}

return bRes;
}

/**
* 发送数据,此函数需要在独立的子线程中完成,可以考虑做一个发送队列
* 自己开一个子线程对该队列进行处理,就好像connect一样
* @param bt
* @return
*/
public boolean sendMsg( byte[] bt ) {
boolean bRes = false;
if ( !mIsInit ) {

return bRes;
}
try {
ByteBuffer buf = ByteBuffer.wrap(bt);
int nCount = mChannel.write(buf);
if ( nCount > 0 ) {
bRes = true;
}
} catch ( Exception e ) {
e.printStackTrace();
}

return bRes;
}

public Selector getSelector() {
return mSelector;
}

/**
* 是否链接着
* @return
*/
public boolean isConnect() {
if ( !mIsInit ) {
return false;
}
return mChannel.isConnected();
}

/**
* 关闭链接
*/
public void close() {
mIsInit = false;
mRemoteIp = null;
mPort = 0;
try {
if ( mSelector != null ) {
mSelector.close();
}
if ( mChannel != null ) {
mChannel.close();
}
} catch ( Exception e ) {
e.printStackTrace();
}
}

/**
* 重连
* @return
*/
public void reConnect() {
close();
connect();
}

/**
* 发送一个测试数据到服务器,检测服务器是否关闭
* @return
*/
public boolean canConnectServer() {
boolean bRes = false;
if ( !isConnect() ) {
return bRes;
}
try {
mChannel.socket().sendUrgentData(0xff);
} catch ( Exception e ) {
e.printStackTrace();
}
return bRes;
}

/**
* 每次读完数据后,需要重新注册selector读取数据
* @return
*/
private synchronized boolean repareRead() {
boolean bRes = false;
try {
//打开并注册选择器到信道
mSelector = Selector.open();
if ( mSelector != null ) {
mChannel.register(mSelector, SelectionKey.OP_READ);
bRes = true;
}
} catch ( Exception e ) {
e.printStackTrace();
}
return bRes;
}

public void revMsg() {
if ( mSelector == null ) {
return;
}
boolean bres = true;
while ( mIsInit ) {
if ( !isConnect() ) {
bres = false;
}
if ( !bres ) {
try {
Thread.sleep(100);
} catch ( Exception e ) {
e.printStackTrace();
}

continue;
}

try {
//有数据就一直接收
while (mIsInit && mSelector.select() > 0) {
for ( SelectionKey sk : mSelector.selectedKeys() ) {
//如果有可读数据
if ( sk.isReadable() ) {
//使用NIO读取channel中的数据
SocketChannel sc = (SocketChannel)sk.channel();
//读取缓存
ByteBuffer readBuffer = ByteBuffer.allocate(READ_BUFF_SIZE);
//实际的读取流
ByteArrayOutputStream read = new ByteArrayOutputStream();
int nRead = 0;
int nLen = 0;
//单个读取流
byte[] bytes;
//读完为止
while ( (nRead = sc.read(readBuffer) ) > 0 ) {
//整理
readBuffer.flip();
bytes = new byte[nRead];
nLen += nRead;
//将读取的数据拷贝到字节流中
readBuffer.get(bytes);
//将字节流添加到实际读取流中
read.write(bytes);
/////////////////////////////////////
//@ 需要增加一个解析器,对数据流进行解析

/////////////////////////////////////

readBuffer.clear();
}
if ( nLen > 0 ) {
if ( mEventListener != null ) {
mEventListener.recvMsg(read);
} else {
String info = new String(read.toString(BUFF_FORMAT));
System.out.println("rev:"+info);
}
}

//为下一次读取做准备
sk.interestOps(SelectionKey.OP_READ);
}

//删除此SelectionKey
mSelector.selectedKeys().remove(sk);
}
}
} catch ( Exception e ) {
e.printStackTrace();
}
}

}

高可用 高并发java中间件 有哪些: 我用的JAVA NIO,一般常用的高并发IO框架,也是用的这个做扩展。

Java NIO是在jdk1.4开始使用的,它既可以说成“新I/O”,也可以说成非阻塞式I/O。下面是java NIO的工作原理:

1. 由一个专门的线程来处理所有的 IO 事件,并负责分发。
2. 事件驱动机制:事件到的时候触发,而不是同步的去监视事件。
3. 线程通讯:线程之间通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。

Java NIO的服务端只需启动一个专门的线程来处理所有的 IO 事件,这种通信模型是怎么实现的呢?呵呵,我们一起来探究它的奥秘吧。java NIO采用了双向通道(channel)进行数据传输,而不是单向的流(stream),在通道上可以注册我们感兴趣的事件。一共有以下四种事件:

事件名 对应值
服务端接收客户端连接事件 SelectionKey.OP_ACCEPT(16)
客户端连接服务端事件 SelectionKey.OP_CONNECT(8)
读事件 SelectionKey.OP_READ(1)
写事件 SelectionKey.OP_WRITE(4)

服务端和客户端各自维护一个管理通道的对象,我们称之为selector,该对象能检测一个或多个通道 (channel) 上的事件。我们以服务端为例,如果服务端的selector上注册了读事件,某时刻客户端给服务端发送了一些数据,阻塞I/O这时会调用read()方法阻塞地读取数据,而NIO的服务端会在selector中添加一个读事件。服务端的处理线程会轮询地访问selector,如果访问selector时发现有感兴趣的事件到达,则处理这些事件,如果没有感兴趣的事件到达,则处理线程会一直阻塞直到感兴趣的事件到达为止。下面是我理解的java NIO的通信模型示意图:

Java NIO怎么理解通道和非阻塞: nio引入了buffer、channel、selector等概念。
通道相当于之前的I/O流。
“通道”太抽象了。java解释不清的东西只能看它底层是怎么解释的——操作系统的I/O控制,通道控制方式?
I/O设备:CPU——通道——设备控制器——I/O设备
(通道和设备控制器的关系是多对多,设备控制器和I/O设备的关系也是多对多。)
I/O过程,参考http://www.nbrkb.net/lwt/jsjsj/asm/INTR&DMA.htm:
1.CPU在执行用户程序时遇到I/O请求,根据用户的I/O请求生成通道程序(也可以是事先编好的)。放到内存中,并把该通道程序首地址放入CAW中。
2.CPU执行“启动I/O”指令,启动通道工作。
3.通道接收“启动I/O”指令信号,从CAW(记录下一条通道指令存放的地址)中取出通道程序首地址,并根据此地址取出通道程序的第一条指令,放入CCW(记录正在执行的通道指令)中;同时向CPU发回答信号,通知“启动I/O”指令完成完毕,CPU可继续执行。
4.与此同时,通道开始执行通道程序,进行物理I/O操作。当执行完一条指令后,如果还有下一条指令则继续执行;否则表示传输完成,同时自行停止,通知CPU转去处理通道结束事件,并从CCW中得到有关通道状态。

如此一来,主处理器只要发出一个I/O操作命令,剩下的工作完全由通道负责。I/O操作结束后,I/O通道会发出一个中断请求,表示相应操作已完成。

通道控制方式是对数据块进行处理的,并非字节。

通道控制方式就是异步I/O,参考http://blog.csdn.net/historyasamirror/article/details/5778378:
I/O分两段:1.数据从I/O设备到内核缓冲区。2.数据从内核缓冲区到应用缓冲区

I/O类型:
1.异步I/O不会产生阻塞,程序不会等待I/O完成,继续执行代码,等I/O完成了再执行一个什么回调函数,代码执行效率高。很容易联想到ajax。这个一般用于I/O操作不影响之后的代码执行。
2.阻塞I/O,程序发起I/O操作后,进程阻塞,CPU转而执行其他进程,I/O的两个步骤完成后,向CPU发送中断信号,进程就绪,等待执行。
3.非阻塞I/O并非都不阻塞,其实是第一步不阻塞,第二部阻塞。程序发起I/O操作后,进程一直检查第一步是否完成,CPU一直在循环询问,完成后,进程阻塞直到完成第二步。明白了!这个是“站着茅坑不拉屎”,CPU利用率最低的。逻辑和操作系统的程序直接控制方式一样。
阻塞不阻塞描述的是发生I/O时当前线程的状态。
以上是操作系统的I/O,那么java的nio又是怎样的呢?
个人觉得是模仿了通道控制方式。
先看看nio的示例代码:
服务端TestReadServer.java

import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; public class TestReadServer { /*标识数字*/ private int flag = 0; /*缓冲区大小*/ private int BLOCK = 1024*1024*10; /*接受数据缓冲区*/ private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*发送数据缓冲区*/ private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); private Selector selector; public TestReadServer(int port) throws IOException { // 打开服务器套接字通道 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); // 服务器配置为非阻塞 serverSocketChannel.configureBlocking(false); // 检索与此通道关联的服务器套接字 ServerSocket serverSocket = serverSocketChannel.socket(); // 进行服务的绑定 serverSocket.bind(new InetSocketAddress(port)); // 通过open()方法找到Selector selector = Selector.open(); // 注册到selector,等待连接 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.println("Server Start----"+port+":"); } // 监听 private void listen() throws IOException { while (true) { // 选择一组键,并且相应的通道已经打开 selector.select(); // 返回此选择器的已选择键集。 Set<SelectionKey> selectionKeys = selector.selectedKeys(); Iterator<SelectionKey> iterator = selectionKeys.iterator(); while (iterator.hasNext()) { SelectionKey selectionKey = iterator.next(); iterator.remove(); handleKey(selectionKey); } } } // 处理请求 private void handleKey(SelectionKey selectionKey) throws IOException { // 接受请求 ServerSocketChannel server = null; SocketChannel client = null; String receiveText; String sendText; int count=0; // 测试此键的通道是否已准备好接受新的套接字连接。 if (selectionKey.isAcceptable()) { // 返回为之创建此键的通道。 server = (ServerSocketChannel) selectionKey.channel(); // 接受到此通道套接字的连接。 // 此方法返回的套接字通道(如果有)将处于阻塞模式。 client = server.accept(); // 配置为非阻塞 client.configureBlocking(false); // 注册到selector,等待连接 client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { // 返回为之创建此键的通道。 client = (SocketChannel) selectionKey.channel(); //将缓冲区清空以备下次读取 receivebuffer.clear(); //读取服务器发送来的数据到缓冲区中 System.out.println(System.currentTimeMillis()); count = client.read(receivebuffer); System.out.println(System.currentTimeMillis() + "~"+count); } } /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub int port = 1234; TestReadServer server = new TestReadServer(port); server.listen(); } }客户端TestReadClient.javaimport java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; public class TestReadClient { /*标识数字*/ private static int flag = 0; /*缓冲区大小*/ private static int BLOCK = 1024*1024*10; /*接受数据缓冲区*/ private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*发送数据缓冲区*/ private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); /*服务器端地址*/ private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress( "localhost", 1234); public static void main(String[] args) throws IOException { // TODO Auto-generated method stub // 打开socket通道 SocketChannel socketChannel = SocketChannel.open(); // 设置为非阻塞方式 socketChannel.configureBlocking(false); // 打开选择器 Selector selector = Selector.open(); // 注册连接服务端socket动作 socketChannel.register(selector, SelectionKey.OP_CONNECT); // 连接 socketChannel.connect(SERVER_ADDRESS); // 分配缓冲区大小内存 Set<SelectionKey> selectionKeys; Iterator<SelectionKey> iterator; SelectionKey selectionKey; SocketChannel client; String receiveText; String sendText; int count=0; while (true) { //选择一组键,其相应的通道已为 I/O 操作准备就绪。 //此方法执行处于阻塞模式的选择操作。 selector.select(); //返回此选择器的已选择键集。 selectionKeys = selector.selectedKeys(); //System.out.println(selectionKeys.size()); iterator = selectionKeys.iterator(); while (iterator.hasNext()) { selectionKey = iterator.next(); if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判断此通道上是否正在进行连接操作。 // 完成套接字通道的连接过程。 if (client.isConnectionPending()) { client.finishConnect(); System.out.println("完成连接!"); sendbuffer.clear(); BufferedInputStream br = new BufferedInputStream(new FileInputStream(new File("D:\BigData.zip"))); byte[] b = new byte[BLOCK]; br.read(b); sendbuffer.put(b); sendbuffer.flip(); System.out.println(System.currentTimeMillis()); client.write(sendbuffer); System.out.println(System.currentTimeMillis()); } client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { client = (SocketChannel) selectionKey.channel(); //将缓冲区清空以备下次读取 receivebuffer.clear(); //读取服务器发送来的数据到缓冲区中 count=client.read(receivebuffer); if(count>0){ receiveText = new String( receivebuffer.array(),0,count); System.out.println("客户端接受服务器端数据--:"+receiveText); client.register(selector, SelectionKey.OP_WRITE); } } } selectionKeys.clear(); } } }例子是TestReadClient向TestReadServer发送一个本地文件。TestReadServer收到后每次打印读取到的字节数。

如何体现异步I/O?
看看TestReadClient中的:

if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判断此通道上是否正在进行连接操作。 // 完成套接字通道的连接过程。 if (client.isConnectionPending()) { client.finishConnect();如果没有client.finishConnect();这句等待完成socket连接,可能会报异常:java.nio.channels.NotYetConnectedException

异步的才不会管你有没有连接成功,都会执行下面的代码。这里需要人为的干预。
如果要证明是java的nio单独使用非阻塞I/O,真没办法!!!阻塞非阻塞要查看进程。。。
不过还有种说法,叫异步非阻塞。上面那段,是用异步方式创建连接,进程当然没有被阻塞。使用了finishConnect()这是人为将程序中止,等待连接创建完成(是模仿阻塞将当前进程阻塞掉,还是模仿非阻塞不断轮询访问,不重要了反正是程序卡住没往下执行)。
所以,创建连接的过程用异步非阻塞I/O可以解释的通。那read/write的过程呢?
根据上面例子的打印结果,可以知道这个过程是同步的,没执行完是不会执行下面的代码的。至于底下是使用阻塞I/O还是非阻塞I/O,对于应用级程序来说不重要了。
阻塞还是非阻塞,对于正常的开发(创立连接,从连接中读写数据)并没有多少的提升,操作过程都类似。
那NIO凭什么成为高性能架构的基础,比起IO,性能优越在哪里,接着猜。。。
java nio有意模仿操作系统的通道控制方式,那他的底层是不是就是直接使用操作系统的通道?
通道中的数据是以块为单位的,之前的流是以字节为单位的,同样的数据流操作外设的次数较多。代码中channel都是针对ByteBuffer对象进行read/write的,而ByteBuffer又是ByteBuffer.allocate(BLOCK);这样创建的,是一个连续的块空间。
那ByteBuffer是不是也是模拟操作系统的缓存?
缓存在io也有,如BufferedInputStream。CPU和外设的速度差很多,缓存为了提高CPU使用率,等外设将数据读入缓存后,CPU再统一操作,不用外设读一次,CPU操作一次,CPU的效率会被拉下来。。。

Java Web开发中高并发量连接一般用什么技术处理?说详细点具体点 列出来: 有多高?这个有很大区别
你去搜索一下 “F5” 负载均衡,从硬件角度解决

50~500/秒 的并发一般的服务器+tomcat 都可以承受。

所以很难理解你的 web 要给多少人用呀?假设10万人集中在10分钟内一起操作,也就是每分钟1万,也就 200/秒 都不到。就算正太分布,也就 需要700/秒,服务器稍好,弄个weblogic,或者websphere 就搞定了呀

  • 昆山京东物流在哪

    韩国衣服尺码为:91-97-165的91-97是什么意思?: 韩国衣服尺寸分为85-110分别对应,85-155CM 90-160CM 95-165cm 100-170cm 105-175cm 110-180cm 其中女士最小为85 最大为105 男士最小为90 最大为110 ...

    501条评论 2583人喜欢 6461次阅读 310人点赞
  • mac如何格式化u盘

    133度46分27秒减165度48分36秒除于4: (133度46分27秒 - 165度48分36秒) / 4= -32度2分9秒 / 4= -8度0分32.25秒 ...

    221条评论 4156人喜欢 3985次阅读 849人点赞
  • dnf的宠物有哪些

    165度的角用三角板怎么画图片: 先画一个180°的平角(画一条直线,中间任取一点做待求角的顶点。)用三角板的45°(减),再用30°角(加)。最后得到的角度是180-45+30=165(度) 高中物理老师为你解答,满意了请采纳吧! ...

    833条评论 5598人喜欢 1819次阅读 799人点赞
  • painless destiny是谁

    在0~360度内-165度角的相同终边角怎么求: 求采纳 ...

    330条评论 5210人喜欢 2594次阅读 828人点赞
  • mac 双系统如何

    用三角板拼一个165度的角。图片: 两个三角板直角边重叠,取两个斜边的夹角。计算是这样的:45-30=15,180-15=165. ...

    313条评论 1773人喜欢 2466次阅读 802人点赞
  • iphone缓存电影软件有哪些

    老挝北纬165度东经101度是哪里?: 地球上根本没有北纬165度,不过我知道11月21日五时03分在老挝北纬19.65度,东经101.25度发生5.8级地震,震源深度十千米,在老挝的博胶省附近 ...

    526条评论 1177人喜欢 5303次阅读 628人点赞