说三道四技术文摘-感悟人生的经典句子
说三道四 > 文档快照

Android开发进阶之NIO非阻塞包(八)

HTML文档下载 WORD文档下载 PDF文档下载
Android开发进阶之NIO非阻塞包(八)

作者:Android开发网


   在整个DDMS中体现Android NIO主要框架的要数MonitorThread.java这个文件了,有关PC和Android手机同步以及NIO非阻塞编程的精髓可以在下面的文件中充分体现出来。

  final class MonitorThread extends Thread {

    private static final int CLIENT_READY = 2;

    private static final int CLIENT_DISCONNECTED = 3;

    private volatile boolean mQuit = false;

    private ArrayList<Client> mClientList; //用一个数组保存客户端信息

    private Selector mSelector;

    private HashMap<Integer, ChunkHandler> mHandlerMap; //这里Android123提示大家,由于在多线程中concurrentHashMap效率比HashMap更安全高效,推荐使用并发库的这个替代版本。

    private ServerSocketChannel mDebugSelectedChan; //一个用于调试的服务器通道

    private int mNewDebugSelectedPort;

    private int mDebugSelectedPort = -1;

    private Client mSelectedClient = null;

    private static MonitorThread mInstance;

    private MonitorThread() {
        super("Monitor");
        mClientList = new ArrayList<Client>();
        mHandlerMap = new HashMap<Integer, ChunkHandler>();

        mNewDebugSelectedPort = DdmPreferences.getSelectedDebugPort();
    }

    static MonitorThread createInstance() {  //创建实例
        return mInstance = new MonitorThread();
    }

    static MonitorThread getInstance() { //获取实例
        return mInstance;
    }

    synchronized void setDebugSelectedPort(int port) throws IllegalStateException { //设置调试端口号
        if (mInstance == null) {
            return;
        }

        if (AndroidDebugBridge.getClientSupport() == false) {
            return;
        }

        if (mDebugSelectedChan != null) {
            Log.d("ddms", "Changing debug-selected port to " + port);
            mNewDebugSelectedPort = port;
            wakeup(); //这里用来唤醒所有的Selector
        } else {
            // we set mNewDebugSelectedPort instead of mDebugSelectedPort so that it's automatically
            mNewDebugSelectedPort = port;
        }
    }

    synchronized void setSelectedClient(Client selectedClient) {
        if (mInstance == null) {
            return;
        }

        if (mSelectedClient != selectedClient) {
            Client oldClient = mSelectedClient;
            mSelectedClient = selectedClient;

            if (oldClient != null) {
                oldClient.update(Client.CHANGE_PORT);
            }

            if (mSelectedClient != null) {
                mSelectedClient.update(Client.CHANGE_PORT);
            }
        }
    }

    Client getSelectedClient() {
        return mSelectedClient;
    }

    boolean getRetryOnBadHandshake() {
        return true; // TODO? make configurable
    }

    Client[] getClients() {
        synchronized (mClientList) {
            return mClientList.toArray(new Client[0]);
        }
    }

    synchronized void registerChunkHandler(int type, ChunkHandler handler) {
        if (mInstance == null) {
            return;
        }

        synchronized (mHandlerMap) {
            if (mHandlerMap.get(type) == null) {
                mHandlerMap.put(type, handler);
            }
        }
    }

    @Override
    public void run() { //本类的主要线程
        Log.d("ddms", "Monitor is up");

        try {
            mSelector = Selector.open();
        } catch (IOException ioe) {
            Log.logAndDisplay(LogLevel.ERROR, "ddms",
                    "Failed to initialize Monitor Thread: " + ioe.getMessage());
            return;
        }

        while (!mQuit) {

            try {
                synchronized (mClientList) {
                }

                try {
                    if (AndroidDebugBridge.getClientSupport()) {
                        if ((mDebugSelectedChan == null ||
                                mNewDebugSelectedPort != mDebugSelectedPort) &&
                                mNewDebugSelectedPort != -1) {
                            if (reopenDebugSelectedPort()) {
                                mDebugSelectedPort = mNewDebugSelectedPort;
                            }
                        }
                    }
                } catch (IOException ioe) {
                    Log.e("ddms",
                            "Failed to reopen debug port for Selected Client to: " + mNewDebugSelectedPort);
                    Log.e("ddms", ioe);
                    mNewDebugSelectedPort = mDebugSelectedPort; // no retry
                }

                int count;
                try {
                    count = mSelector.select();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                    continue;
                } catch (CancelledKeyException cke) {
                    continue;
                }

                if (count == 0) {
                    continue;
                } //这里代码写的不是很好,Android开发网提示大家因为这个NIO是DDMS工作在PC端的还不明显,这样轮训的在一个while中,效率不是很高,CPU很容易占用率很高。

                Set<SelectionKey> keys = mSelector.selectedKeys();
                Iterator<SelectionKey> iter = keys.iterator(); //使用迭代器获取这个选择键

                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    iter.remove();

                    try {
                        if (key.attachment() instanceof Client) { //判断收到的key的附件是否是Client的实例
                            processClientActivity(key);
                        }
                        else if (key.attachment() instanceof Debugger) { //如果是Debug实例
                            processDebuggerActivity(key);
                        }
                        else if (key.attachment() instanceof MonitorThread) {
                            processDebugSelectedActivity(key);
                        }
                        else {
                            Log.e("ddms", "unknown activity key");
                        }
                    } catch (Exception e) {
                        Log.e("ddms", "Exception during activity from Selector.");
                        Log.e("ddms", e);
                    }
                }
            } catch (Exception e) {
                Log.e("ddms", "Exception MonitorThread.run()");
                Log.e("ddms", e);
            }
        }
    }

    int getDebugSelectedPort() {
        return mDebugSelectedPort;
    }

    private void processClientActivity(SelectionKey key) {
        Client client = (Client)key.attachment();

        try {
            if (key.isReadable() == false || key.isValid() == false) {
                Log.d("ddms", "Invalid key from " + client + ". Dropping client.");
                dropClient(client, true /* notify */);
                return;
            }

            client.read();

            JdwpPacket packet = client.getJdwpPacket();
            while (packet != null) {
                if (packet.isDdmPacket()) {
                    // unsolicited DDM request - hand it off
                    assert !packet.isReply();
                    callHandler(client, packet, null);
                    packet.consume();
                } else if (packet.isReply()
                        && client.isResponseToUs(packet.getId()) != null) {
                    // reply to earlier DDM request
                    ChunkHandler handler = client
                            .isResponseToUs(packet.getId());
                    if (packet.isError())
                        client.packetFailed(packet);
                    else if (packet.isEmpty())
                        Log.d("ddms", "Got empty reply for 0x"
                                + Integer.toHexString(packet.getId())
                                + " from " + client);
                    else
                        callHandler(client, packet, handler);
                    packet.consume();
                    client.removeRequestId(packet.getId());
                } else {
                    Log.v("ddms", "Forwarding client "
                            + (packet.isReply() ? "reply" : "event") + " 0x"
                            + Integer.toHexString(packet.getId()) + " to "
                            + client.getDebugger());
                    client.forwardPacketToDebugger(packet);
                }

                packet = client.getJdwpPacket();
            }
        } catch (CancelledKeyException e) { //注意正确处理这个异常
            dropClient(client, true /* notify */);
        } catch (IOException ex) {
            dropClient(client, true /* notify */);
        } catch (Exception ex) {
            Log.e("ddms", ex);

            dropClient(client, true /* notify */);

            if (ex instanceof BufferOverflowException) { //可能存在缓冲区异常
                Log.w("ddms",
                        "Client data packet exceeded maximum buffer size "
                                + client);
            } else {
                // don't know what this is, display it
                Log.e("ddms", ex);
            }
        }
    }

    private void callHandler(Client client, JdwpPacket packet,
            ChunkHandler handler) {

        // on first DDM packet received, broadcast a "ready" message
        if (!client.ddmSeen())
            broadcast(CLIENT_READY, client);

        ByteBuffer buf = packet.getPayload();
        int type, length;
        boolean reply = true;

        type = buf.getInt();
        length = buf.getInt();

        if (handler == null) {
            // not a reply, figure out who wants it
            synchronized (mHandlerMap) {
                handler = mHandlerMap.get(type);
                reply = false;
            }
        }

        if (handler == null) {
            Log.w("ddms", "Received unsupported chunk type "
                    + ChunkHandler.name(type) + " (len=" + length + ")");
        } else {
            Log.d("ddms", "Calling handler for " + ChunkHandler.name(type)
                    + " [" + handler + "] (len=" + length + ")");
            ByteBuffer ibuf = buf.slice();
            ByteBuffer roBuf = ibuf.asReadOnlyBuffer(); // enforce R/O
            roBuf.order(ChunkHandler.CHUNK_ORDER);
            synchronized (mClientList) {
                handler.handleChunk(client, type, roBuf, reply, packet.getId());
            }
        }
    }

    synchronized void dropClient(Client client, boolean notify) {
        if (mInstance == null) {
            return;
        }

        synchronized (mClientList) {
            if (mClientList.remove(client) == false) {
                return;
            }
        }
        client.close(notify);
        broadcast(CLIENT_DISCONNECTED, client);

        /*
         * http://forum.java.sun.com/thread.jspa?threadID=726715&start=0
         * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5073504
         */
        wakeup();
    }

    /*
     * Process activity from one of the debugger sockets. This could be a new
     * connection or a data packet.
     */
    private void processDebuggerActivity(SelectionKey key) {
        Debugger dbg = (Debugger)key.attachment();

        try {
            if (key.isAcceptable()) { //处理Server响应这个事件
                try {
                    acceptNewDebugger(dbg, null);
                } catch (IOException ioe) {
                    Log.w("ddms", "debugger accept() failed");
                    ioe.printStackTrace();
                }
            } else if (key.isReadable()) { //如果是收到的数据,则可读取
                processDebuggerData(key);
            } else {
                Log.d("ddm-debugger", "key in unknown state");
            }
        } catch (CancelledKeyException cke) { //记住,NIO处理这个异常,很多入门的开发者很容易忘记
            // key has been cancelled we can ignore that.
        }
    }

     private void acceptNewDebugger(Debugger dbg, ServerSocketChannel acceptChan) //这里用到了阻塞方式
            throws IOException {

        synchronized (mClientList) {
            SocketChannel chan;

            if (acceptChan == null)
                chan = dbg.accept();
            else
                chan = dbg.accept(acceptChan);

            if (chan != null) {
                chan.socket().setTcpNoDelay(true);

                wakeup();

                try {
                    chan.register(mSelector, SelectionKey.OP_READ, dbg);
                } catch (IOException ioe) {
                    // failed, drop the connection
                    dbg.closeData();
                    throw ioe;
                } catch (RuntimeException re) {
                    // failed, drop the connection
                    dbg.closeData();
                    throw re;
                }
            } else {
                Log.w("ddms", "ignoring duplicate debugger");
            }
        }
    }

    private void processDebuggerData(SelectionKey key) {
        Debugger dbg = (Debugger)key.attachment();

        try {
            dbg.read();

            JdwpPacket packet = dbg.getJdwpPacket();
            while (packet != null) {
                Log.v("ddms", "Forwarding dbg req 0x"
                        + Integer.toHexString(packet.getId()) + " to "
                        + dbg.getClient());

                dbg.forwardPacketToClient(packet);

                packet = dbg.getJdwpPacket();
            }
        } catch (IOException ioe) {
            Log.d("ddms", "Closing connection to debugger " + dbg);
            dbg.closeData();
            Client client = dbg.getClient();
            if (client.isDdmAware()) {
                   Log.d("ddms", " (recycling client connection as well)");

                    client.getDeviceImpl().getMonitor().addClientToDropAndReopen(client,
                        IDebugPortProvider.NO_STATIC_PORT);
            } else {
                Log.d("ddms", " (recycling client connection as well)");
                // we should drop the client, but also attempt to reopen it.
                // This is done by the DeviceMonitor.
                client.getDeviceImpl().getMonitor().addClientToDropAndReopen(client,
                        IDebugPortProvider.NO_STATIC_PORT);
            }
        }
    }

    private void wakeup() {
        mSelector.wakeup();
    }

    synchronized void quit() {
        mQuit = true;
        wakeup();
        Log.d("ddms", "Waiting for Monitor thread");
        try {
            this.join();
            // since we're quitting, lets drop all the client and disconnect
            // the DebugSelectedPort
            synchronized (mClientList) {
                for (Client c : mClientList) {
                    c.close(false /* notify */);
                    broadcast(CLIENT_DISCONNECTED, c);
                }
                mClientList.clear();
            }

            if (mDebugSelectedChan != null) {
                mDebugSelectedChan.close();
                mDebugSelectedChan.socket().close();
                mDebugSelectedChan = null;
            }
            mSelector.close();
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        mInstance = null;
    }

    synchronized void addClient(Client client) {
        if (mInstance == null) {
            return;
        }

        Log.d("ddms", "Adding new client " + client);

        synchronized (mClientList) {
            mClientList.add(client);

            try {
                wakeup();

                client.register(mSelector);

                Debugger dbg = client.getDebugger();
                if (dbg != null) {
                    dbg.registerListener(mSelector);
                }
            } catch (IOException ioe) {
                // not really expecting this to happen
                ioe.printStackTrace();
            }
        }
    }

    /*
     * Broadcast an event to all message handlers.
     */
    private void broadcast(int event, Client client) {
        Log.d("ddms", "broadcast " + event + ": " + client);

        /*
         * The handler objects appear once in mHandlerMap for each message they
         * handle. We want to notify them once each, so we convert the HashMap
         * to a HashSet before we iterate.
         */
        HashSet<ChunkHandler> set;
        synchronized (mHandlerMap) {
            Collection<ChunkHandler> values = mHandlerMap.values();
            set = new HashSet<ChunkHandler>(values);
        }

        Iterator<ChunkHandler> iter = set.iterator();
        while (iter.hasNext()) {
            ChunkHandler handler = iter.next();
            switch (event) {
                case CLIENT_READY:
                    try {
                        handler.clientReady(client);
                    } catch (IOException ioe) {
                        // Something failed with the client. It should
                        // fall out of the list the next time we try to
                        // do something with it, so we discard the
                        // exception here and assume cleanup will happen
                        // later. May need to propagate farther. The
                        // trouble is that not all values for "event" may
                        // actually throw an exception.
                        Log.w("ddms",
                                "Got exception while broadcasting 'ready'");
                        return;
                    }
                    break;
                case CLIENT_DISCONNECTED:
                    handler.clientDisconnected(client);
                    break;
                default:
                    throw new UnsupportedOperationException();
            }
        }

    }

    /**
     * Opens (or reopens) the "debug selected" port and listen for connections.
     * @return true if the port was opened successfully.
     * @throws IOException
     */
    private boolean reopenDebugSelectedPort() throws IOException {

        Log.d("ddms", "reopen debug-selected port: " + mNewDebugSelectedPort);
        if (mDebugSelectedChan != null) {
            mDebugSelectedChan.close();
        }

        mDebugSelectedChan = ServerSocketChannel.open();
        mDebugSelectedChan.configureBlocking(false); // required for Selector

        InetSocketAddress addr = new InetSocketAddress(
                InetAddress.getByName("localhost"), //$NON-NLS-1$
                mNewDebugSelectedPort);
        mDebugSelectedChan.socket().setReuseAddress(true); // enable SO_REUSEADDR

        try {
            mDebugSelectedChan.socket().bind(addr);
            if (mSelectedClient != null) {
                mSelectedClient.update(Client.CHANGE_PORT);
            }

            mDebugSelectedChan.register(mSelector, SelectionKey.OP_ACCEPT, this);

            return true;
        } catch (java.net.BindException e) {
            displayDebugSelectedBindError(mNewDebugSelectedPort);

            // do not attempt to reopen it.
            mDebugSelectedChan = null;
            mNewDebugSelectedPort = -1;

            return false;
        }
    }

    /*
     * We have some activity on the "debug selected" port. Handle it.
     */
    private void processDebugSelectedActivity(SelectionKey key) {
        assert key.isAcceptable();

        ServerSocketChannel acceptChan = (ServerSocketChannel)key.channel();

        /*
         * Find the debugger associated with the currently-selected client.
         */
        if (mSelectedClient != null) {
            Debugger dbg = mSelectedClient.getDebugger();

            if (dbg != null) {
                Log.d("ddms", "Accepting connection on 'debug selected' port");
                try {
                    acceptNewDebugger(dbg, acceptChan);
                } catch (IOException ioe) {
                    // client should be gone, keep going
                }

                return;
            }
        }

        Log.w("ddms",
                "Connection on 'debug selected' port, but none selected");
        try {
            SocketChannel chan = acceptChan.accept();
            chan.close();
        } catch (IOException ioe) {
            // not expected; client should be gone, keep going
        } catch (NotYetBoundException e) {
            displayDebugSelectedBindError(mDebugSelectedPort);
        }
    }

    private void displayDebugSelectedBindError(int port) {
        String message = String.format(
                "Could not open Selected VM debug port (%1$d). Make sure you do not have another instance of DDMS or of the eclipse plugin running. If it's being used by something else, choose a new port number in the preferences.",
                port);

        Log.logAndDisplay(LogLevel.ERROR, "ddms", message);
    }
}

  从上面来看Android的开源代码有关PC上的写的不是很好,很多实现的地方都是用了严重的缝缝补补方式解决,有些习惯不是很到位,有关本NIO例子由于涉及的项目对象多,理解需要网友深入分析DDMS源码中的每个对象。细节写的不是很理想,Android123推荐大家,画出UML后再分析更清晰。

实现图象局部放大的原理和方法-Delphi资料 使用Delphi实现滚动式面板窗口 通用的MsgBox-Delphi资料 图象放大镜——实现图象局部放大的原理和方法-Delphi资料 图形的特殊显示效果-Delphi资料 图形整体拉出效果-Delphi资料 一个实用的Delphi屏幕拷贝程序的设计 用Delphi 显示122种图形特效 用Delphi编写DLL实现动态改变分辨率 用Delphi进行OpenGL编程学习心得 用Delphi开发windows95屏幕保护预览程序 用Delphi实现壁纸更换 用DELPHI实现位图显示特技 用DELPHI中Canvas特性开发图形软件 用构件变换法实现动画效果-Delphi资料 在Delphi中使用动态图标 在Delphi中显示Windows图标 在多媒体文件中批量抓取图象-Delphi资料 怎样读出不同格式图形的高和宽-Delphi资料 怎样使用PageUp、PageDown滚动窗体-Delphi资料 怎样制作全透明的窗口-Delphi资料 DELPHI:FormContainer简易手册 Delphi:用FormContainer渐变效果 Delphi4的窗口融合技术 Delphi使用技巧ABC Delphi使用技巧四则 DELPHI中自适应表单的实现 TList的用法-Delphi资料 不规则窗口的实现-Delphi资料 不用标题栏也移动窗体-Delphi资料 窗口建立和关闭时的特效-Delphi资料 如何用在两次用getTime()中得到两个不同的时间。 一个类似于牛角尖的问题(多余的CONST),不能忽视,请各位高手详细说明!!谢谢! 怎样读写注册表,每次都不成功,气死我也~! 各位救命啊,用 TClientDataSet.Load XML 的问题。。。。 娃呀呀,pb8怎么这么难安装?jaguar组建就用了5分钟,regester window又用了10分钟,重启动后,还没完,偶不敢装了,把碟退了出来,大家是不是也这样?//牛虻 请教高手一个ado的问题. 请问一个TWebBrowser的问题 请问:系统崩溃后,找不到BOOT,系统告诉:DOS基本分区为格式化?无法引导启动! 在VB.NET的tabcontrol上放置AxMSFlexGrid控件问题,急 java3D 现在大家是用Oracle 8还是 Oracle 9??? C++问题求助! 请教一个错误的原因. 各位大侠请问Jeffrey Richter的windows核心程序设计是不是就是andvanced windows程序设计的第四版 SCJP里的那些什么300-020,020是什么意思啊? 请问一个关于document.write()方法的问题。急啊! 初学者,欢迎灌水。 Delphi6的Bug?不兼容? 为什么我用GetProfileString()却总是得不到结果 sos 请教各位大侠一个问题 delphi6中的installShield 请介绍接收端CRC校验传输内容是否正确的方法,资料或代码。谢谢! 各位大侠请问Jeffrey Richter的windows核心程序设计是不是就是andvanced windows程序设计的第四版? 谁会做软件狗?有钱赚了!!! 为什么我用QuickRep作的报表只能显示一条记录,而且columnHeaderBand上内容也显示不出来 请问在税务局开发数据库的同行么?? 大家好各位大侠请问Jeffrey Richter的windows核心程序设计是不是就是andvanced windows程序设计的第四版? 谁做过软件狗,马上来拿钱!!! 江苏省的成绩什么时候可以出来啊,我是徐州的 shockwaveflash没有hwnd,怎么办? chechy(chechy) 你在吗? 一个关于用excel做的日报的问题 谁会做软件狗,马上来拿钱!!! 给你下跪了,给你磕头了,给你鞠躬了。很简单的问题。谢谢 那位大哥能告诉我在VC中我要创建类的话应该做哪些工作步骤(要详细的,呵呵) 紧急求救,asp连接mysql问题 在使用twebbrowser的时候,怎样制止网页的自动刷新和跳转? vc编译器错了怎么办???突然死机,然后就不好好干了!!谢谢 ?如何将二进制的 值写如注册表? Delphi紧急求助! 我想问的是,返回的 ResultSet 中的某个字段(int 型),如何放到一个 int[]数组里去。因为 ResultSet 不知道怎样取 size,我又不想用 vector, ResultSet的getArray()方法也是莫名其妙。 c盘格式化后,怎样找到linux系统? 有意思 过来研究一下!!!!insert 的!!!!难道 25 不是 long integer 吗 我的程序debug版,一直调试好好的,我rebuid all 一下就出错了,错误如下:怎么回事? 位图问题? 怎样使用自定义的光标??? 我想找Hopen SDK的开发包。 为什么我的iis总是报500内部服务器错误。我先装的framework,后来升级了ie5.5,最后在w2kprofessional上装了iis,手动添加了aspx解析:指向aspnet_isapi.dll,为什么还报错? 那里有关于用组件上传图片并且显示上传图片的介绍 NT 上已安装好mysql服务器,WIN98 client连接不上,求救 程序员梦难圆,请大家给我这个非计算机专业的兄弟出出主意。 想了解一下各种气候类型的特点,这不是快要地理生物会考了嘛.认真学习一下. 用温暖各说一句话; 表示气候 表示心情 急 关于压力容器设计订货方给的工作参数怎么来分析?比如说排污扩容器 容积:3.5方 工作压力0.15MPA 工作温度≤250℃ 怎么分析这些数据来做CDA图纸 沼气池建好后,每天会产1万方的沼气提纯成5000方天然气压缩成20兆帕的一个成套设备需要投资多少钱啊?运行费用每立方需要多少成本?(沼气池是无动力运行的,每天自动产1万立方沼气) 请问你是哪个公司?我们对沼气提纯也很感兴趣 计算机的应用范围有哪些? 沼气提纯的技术设备大概需要多少的资金 用温暖各说一句话,表示是气候的、心情的 压力容器分为一二三类,分为高压低压中压容器、分为反应、换热、分离、储存容器,这些关于压力容器的分类,有哪些法规依据呢?麻烦亲列举一下 秋天的落叶宛如什么 沼气超压吸附法提纯 市场调查的应用范围是什么 一天中,阳光下物体的影子随气温的升高而缩短,随气温的降低而增长.判断对错判断是对是错 表示天气或心情好的诗句随便说两句 21.根据《广东省突发气象灾害预警信号发布规定》,悬挂 ____预警信号时中小学应该停课.A.暴雨橙色 B.暴雨红色C.高温橙色 D.高温红色 汽车牌号都有什么颜色的 车牌号靠前的都是领导的车吗 比如说鲁C00001 秋天的落叶简介 气象部门发布的气象灾害预警信号,危害程度最高的是哪种颜色 汽车不同颜色的含义 瓦斯提纯有哪些方法? 上海发布过哪些突发气象灾害预警信号 大众汽车后面的TSI字母不同颜色代表什么意思?意向车型:大众 迈腾有的是T是红色的 有的是SI是红色的 有的是I是红色的 提纯混有甲烷的乙烯用什么方法?常用的简单方法 算盘是我国传统得计算工具是褒义词、贬义词还是中性词阎王好见,(小鬼)难求!是中性、褒义、贬义 压力容器的定期检查分为 沼气怎么提炼甲烷 他的小算盘打得很精是褒义词还是贬义词还是中性词 混凝土裂缝的产生混凝土在下列情况下,均能导致其产生裂缝,试解释裂缝产生的原因,并指出主要防止措施.水泥水化热大;水泥安定性不良;大气温度变化较大;碱一骨料反应;混凝土碳化; 压力容器首检周期 氨系统油冷器是压力容器吗? 法国的气候类型 比喻句 什么什么像是什么这道题是这样的:—————————————————,像是——————————————————.不能太简单了,不能像这样:月亮,像是香蕉.这样不给分的, 压力容器检验工程师、监检压力容器检验工程师,从事压力容器、化工机械的制造监检,工地安装监检,(一般做为第三方)需要哪些资格证?最好详细点, 法国气候类型 秋天的落叶的比喻句有啥?一定要很形容的,很逼真的! 压力容器是否必须由当地的质监部门的特检所检验 法国有什么气候类型?急 我国古代有很多测量时间的工具,你能列举几种仪器的名称吗?请重中选取一种,谈谈其中应用的原理. 空冷器是什么 法国的气候具有什么特点? 一道很麻烦的数学题,摆脱各位牛X人士,回答沙漏又称沙钟,是我国古代一种计量时间的仪器,它是题目如下沙漏又称沙钟,是我国古代一种计量时间的仪器,它是根据流沙从一个容器漏到另一个容 有哪些气象预警警报? 秋天的落叶,散文开头,落叶的描写我只要一小段开头,很有意境的那种,不要敷衍, 气候分区的表示方法:2-1-4表示啥意思 古代中国时间是什么?具体时间 谁能写《秋天的落叶》作文(纯属自写,不能和其他重复). 对秋天的落叶说点什么 中国古代的时间是如何计算的.比如一盏茶的时间算现在多少 世界上最深的地震裂缝有多深?哪些地震裂缝超深? 古代人和现代人是如何测量时间的?测量时间的工具是如何发展变化的 一寸光阴一寸金日晷 我国古代是怎样计量时间的 地震时造成大地出现裂缝然后那个裂缝是怎样补救的不过我还有一点不明白,就是沙的空隙会有很多'而地震时裂开的缝隙应该是土'然而给他灌沙他起不了很大的坚固性啊. 压力容器定期检验包括哪些内容? 中国古代时间更指什么 什么是地震深度? 压力容器是不是以内压进行实验的 赛尔号收集甲烷燃气的装备在哪要 地震时产生地面裂缝 裂缝下面是什么了?如题 为什么人掉下去之后会怎么样呢? 请问中国做得比较好的沼气提纯设备和工艺的商家有哪些? 压力容器怎么报价
备案号:鲁ICP备13029499号-2 说三道四 www.s3d4.cn