zoukankan      html  css  js  c++  java

  • 第十章 Android的消息机制

    Android的消息机制主要是指Handler的运行机制，Handler的运行需要底层MessageQueue和Looper的支撑。MessageQueue是采用单链表的数据结构来存储消息列表。 Looper会以无限循环的形式去查看是否有新消息，如果有就处理消息，否则就一直等待。ThreadLocal可以在不同线程中互不干扰的存储并提供数据，通过ThreadLocal可以轻松的获取每个线程的Looper。

    10.1 Android消息机制概述

    1. Handler的主要作用是将某个任务切换到某个指定的线程中去执行。为什么Android要提供这个功能呢？这是因为Android规定访问UI只能通过主线程，如果子线程访问UI,程序会抛出异常；ViewRootImpl在checkThread方法中做了判断。
    2. 由于Android不建议在主线程进行耗时操作，否则可能会导致ANR。那我们耗时操作在子线程执行完毕后，我们需要将一些更新UI的操作切换到主线程当中去。所以系统就提供了Handler。
    3. 系统为什么不允许在子线程中去访问UI呢？
      因为Android的UI控件不是线程安全的，多线程并发访问可能会导致UI控件处于不可预期的状态，为什么不加锁？因为加锁机制会让UI访问逻辑变得复杂；其次锁机制会降低UI访问的效率，因为锁机制会阻塞某些线程的执行。所以Android采用了高效的单线程模型来处理UI操作。
    4. Handler创建时会采用当前线程的Looper来构建内部的消息循环系统，如果当前线程没有Looper就会报错。Handler可以通过post方法发送一个Runnable到消息队列中，也可以通过send方法发送一个消息到消息队列中，其实post方法最终也是通过send方法来完成。
    5. MessageQueue的enqueueMessage方法最终将这个消息放到消息队列中，当Looper发现有新消息到来时，处理这个消息，最终消息中的Runnable或者Handler的handleMessage方法就会被调用，注意Looper是运行Handler所在的线程中的，这样一来业务逻辑就切换到了Handler所在的线程中去执行了。

    10.2 Android的消息机制分析

    10.2.1 ThreadLocal的工作原理
    1. ThreadLocal是一个线程内部的数据存储类，通过它可以在指定线程存储数据，数据存储后，只能在指定的线程可以获取到存储的数据，对于其他线程则无法获取到数据。一般来说，当数据是以线程作为作用域并且不同线程有不同副本的时候，就可以考虑使用ThreadLocal。对于Handler来说，它需要获取当前线程的Looper,而Looper的作用于就是线程并且不同的线程具有不同的Looper，通过ThreadLocal可以轻松实现线程中的存取。
    2. ThreadLocal的另一个使用场景是复杂逻辑下的对象传递。
    3. ThreadLocal原理：不同线程访问同一个ThreadLoacl的get方法，ThreadLocal的get方法会从各自的线程中取出一个数组，然后再从数组中根据当前ThreadLocal的索引去查找对应的Value值。


    （1） ThreadLocal set方法
    1.  public void set(T value) {
    2.      Thread currentThread = Thread.currentThread();
    3.      Values values = values(currentThread);
    4.      if (values == null) {
    5.          values = initializeValues(currentThread);
    6.      }
    7.      values.put(this, value);
    8.  }
    （2） ThreadLocal get方法
    1.  public T get() {
    2.      // Optimized for the fast path.
    3.      Thread currentThread = Thread.currentThread();
    4.      Values values = values(currentThread);
    5.      if (values != null) {
    6.          Object[] table = values.table;
    7.          int index = hash & values.mask;
    8.          if (this.reference == table[index]) {
    9.              return (T) table[index + 1];
    10.          }
    11.      } else {
    12.          values = initializeValues(currentThread);
    13.      }
    14.      return (T) values.getAfterMiss(this);
    15.  }
    获取当前线程，并从当前线程中获取对应的ThreadLocalMap，通过key获取对应的value；如果未获取到对应的ThreadLocalMap，则创建并将该对象返回。
    （3）ThreadLocal的值在table数值中的位置总是ThreadLocal的索引+1。
    10.2.2 消息队列的工作原理
    1. MessageQueue主要有两个操作，插入和读取，读取操作伴随着删除操作；MessageQueue是通过单链表的数据结构来维护消息列表的。
    2. enqueueMessage方法的作用是往消息队列插入一条消息。next方法是一个无线循环的方法，如果消息队列中没有消息，那么next方法会一直阻塞在这里。当有新消息到来时，next方法会返回这条消息并将其从单链表中移除。

    10.2.4 Handler的工作原理

    1. Handler的工作主要包含消息的发送和接受过程。发送过程通过post的一系列方法和send的一系列方法来实现。Handler发送过程仅仅是向消息队列中插入了一条消息。MessageQueue的next方法就会返回这条消息给Looper，Looper拿到这条消息就开始处理，最终消息会交给Handler来处理。
    Handler处理消息
    1.  public void dispatchMessage(Message msg) {
    2.      if (msg.callback != null) {
    3.          //Message的callback是一个Runnable,       
    4.         //也就是Handler的 post方法所传递的Runnable参数
    5.          handleCallback(msg);
    6.      } else {
    7.          //如果给Handler设置了Callback的实现，
    8.          //则调用Callback的handleMessage(msg)
    9.          if (mCallback != null) {
    10.              if (mCallback.handleMessage(msg)) {
    11.                  return;
    12.              }
    13.          }
    14.          //调用Handler的handleMessage方法来处理消息，
    15.          //该Handler子类需重写handlerMessage(msg)方法
    16.          handleMessage(msg);
    17.      }
    18.  }
    19.  private static void handleCallback(Message message) {
    20.      message.callback.run();
    21.  }
    22.  public interface Callback {
    23.      public boolean handleMessage(Message msg);
    24.  }
    25.  //默认空实现
    26.  public void handleMessage(Message msg) {
    27.  }

    Handler还有一个特殊的构造方法，可以指定一个特殊的Looper来构造Handler。

    1.  public Handler(Looper looper) {
    2.      this(looper, null, false);
    3.  }
    1. Handler创建需要Looper，否则会抛出异常，默认获取当前线程的Looper。主线程也就是ActivityThread会自动创建Looper，其他线程如果需要Looper均需要手动创建。

    10.3 主线程消息循环

    Android的主线程就是ActivityThread，主线程的入口方法为main，在main方法中系统会通过Looper.prepareMainLooper()来创建主线程的Looper以及MessageQueue，并通过Looper.loop()来开启主线程的消息循环。
    1. public static void main(String[] args) {
    2.      ... 
    3.      Process.setArgV0("<pre-initialized>");
    5.      Looper.prepareMainLooper();
    7.      ActivityThread thread = new ActivityThread();
    8.      thread.attach(false);
    10.      if (sMainThreadHandler == null) {
    11.          sMainThreadHandler = thread.getHandler();
    12.      }
    14.      AsyncTask.init();
    16.      if (false) {
    17.          Looper.myLooper().setMessageLogging(new
    18.                  LogPrinter(Log.DEBUG, "ActivityThread"));
    19.      }
    21.      Looper.loop();
    23.      throw new RuntimeException("Main thread loop unexpectedly exited");
    24. }
    Looper.loop()，这里是一个死循环，如果主线程的Looper终止，则应用程序会抛出异常。那么问题来了，既然主线程卡在这里了，（1）那Activity为什么还能启动；（2）点击一个按钮仍然可以响应？
    问题1：startActivity的时候，会向AMS（ActivityManagerService）发一个跨进程请求（AMS运行在系统进程中），之后AMS启动对应的Activity；AMS也需要调用App中Activity的生命周期方法（不同进程不可直接调用），AMS会发送跨进程请求，然后由App的ActivityThread中的ApplicationThread会来处理，ApplicationThread会通过主线程线程的Handler将执行逻辑切换到主线程。重点来了，主线程的Handler把消息添加到了MessageQueue，Looper.loop会拿到该消息，并在主线程中执行。这就解释了为什么主线程的Looper是个死循环，而Activity还能启动，因为四大组件的生命周期都是以消息的形式通过UI线程的Handler发送，由UI线程的Looper执行的。
    问题2：和问题1原理一样，最终都是由系统发消息来处理的，都经过了Looper.loop()。









    http://blog.csdn.net/lmj623565791/article/details/38377229
    下面是博客的内容

    很多人面试肯定都被问到过，请问Android中的Looper , Handler , Message有什么关系？本篇博客目的首先为大家从源码角度介绍3者关系，然后给出一个容易记忆的结论。

    1、 概述

    Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。那么什么叫异步消息处理线程呢？
    异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待。

    说了这一堆，那么和Handler 、 Looper 、Message有啥关系？其实Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

    2、 源码解析

    1、Looper

    对于Looper主要是prepare()和loop()两个方法。
    首先看prepare()方法
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public static final void prepare() {  
    2.         if (sThreadLocal.get() != null) {  
    3.             throw new RuntimeException("Only one Looper may be created per thread");  
    4.         }  
    5.         sThreadLocal.set(new Looper(true));  
    6. }  

    sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。可以看到，在第5行，将一个Looper的实例放入了ThreadLocal，并且2-4行判断了sThreadLocal是否为null，否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例~相信有些哥们一定遇到这个错误。
    下面看Looper的构造方法：
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. private Looper(boolean quitAllowed) {  
    2.         mQueue = new MessageQueue(quitAllowed);  
    3.         mRun = true;  
    4.         mThread = Thread.currentThread();  
    5. }  
    在构造方法中，创建了一个MessageQueue（消息队列）。
    然后我们看loop()方法：
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public static void loop() {  
    2.         final Looper me = myLooper();  
    3.         if (me == null) {  
    4.             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
    5.         }  
    6.         final MessageQueue queue = me.mQueue;  
    7.   
    8.         // Make sure the identity of this thread is that of the local process,  
    9.         // and keep track of what that identity token actually is.  
    10.         Binder.clearCallingIdentity();  
    11.         final long ident = Binder.clearCallingIdentity();  
    12.   
    13.         for (;;) {  
    14.             Message msg = queue.next(); // might block  
    15.             if (msg == null) {  
    16.                 // No message indicates that the message queue is quitting.  
    17.                 return;  
    18.             }  
    19.   
    20.             // This must be in a local variable, in case a UI event sets the logger  
    21.             Printer logging = me.mLogging;  
    22.             if (logging != null) {  
    23.                 logging.println(">>>>> Dispatching to " + msg.target + " " +  
    24.                         msg.callback + ": " + msg.what);  
    25.             }  
    26.   
    27.             msg.target.dispatchMessage(msg);  
    28.   
    29.             if (logging != null) {  
    30.                 logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
    31.             }  
    32.   
    33.             // Make sure that during the course of dispatching the  
    34.             // identity of the thread wasn't corrupted.  
    35.             final long newIdent = Binder.clearCallingIdentity();  
    36.             if (ident != newIdent) {  
    37.                 Log.wtf(TAG, "Thread identity changed from 0x"  
    38.                         + Long.toHexString(ident) + " to 0x"  
    39.                         + Long.toHexString(newIdent) + " while dispatching to "  
    40.                         + msg.target.getClass().getName() + " "  
    41.                         + msg.callback + " what=" + msg.what);  
    42.             }  
    43.   
    44.             msg.recycle();  
    45.         }  
    46. }  

    第2行：
    public static Looper myLooper() {
    return sThreadLocal.get();
    }
    方法直接返回了sThreadLocal存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行。
    第6行：拿到该looper实例中的mQueue（消息队列）
    13到45行：就进入了我们所说的无限循环。
    14行：取出一条消息，如果没有消息则阻塞。
    27行：使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。Msg的target是什么呢？其实就是handler对象，下面会进行分析。
    44行：释放消息占据的资源。

    Looper主要作用：
    1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
    2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。
    好了，我们的异步消息处理线程已经有了消息队列（MessageQueue），也有了在无限循环体中取出消息的哥们，现在缺的就是发送消息的对象了，于是乎：Handler登场了。

    2、Handler

    使用Handler之前，我们都是初始化一个实例，比如用于更新UI线程，我们会在声明的时候直接初始化，或者在onCreate中初始化Handler实例。所以我们首先看Handler的构造方法，看其如何与MessageQueue联系上的，它在子线程中发送的消息（一般发送消息都在非UI线程）怎么发送到MessageQueue中的。
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public Handler() {  
    2.         this(null, false);  
    3. }  
    4. public Handler(Callback callback, boolean async) {  
    5.         if (FIND_POTENTIAL_LEAKS) {  
    6.             final Class<? extends Handler> klass = getClass();  
    7.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
    8.                     (klass.getModifiers() & Modifier.STATIC) == 0) {  
    9.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
    10.                     klass.getCanonicalName());  
    11.             }  
    12.         }  
    13.   
    14.         mLooper = Looper.myLooper();  
    15.         if (mLooper == null) {  
    16.             throw new RuntimeException(  
    17.                 "Can't create handler inside thread that has not called Looper.prepare()");  
    18.         }  
    19.         mQueue = mLooper.mQueue;  
    20.         mCallback = callback;  
    21.         mAsynchronous = async;  
    22.     }  

    14行：通过Looper.myLooper()获取了当前线程保存的Looper实例，然后在19行又获取了这个Looper实例中保存的MessageQueue（消息队列），这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。

    然后看我们最常用的sendMessage方法

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public final boolean sendMessage(Message msg)  
    2.  {  
    3.      return sendMessageDelayed(msg, 0);  
    4.  }  

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {  
    2.      Message msg = Message.obtain();  
    3.      msg.what = what;  
    4.      return sendMessageDelayed(msg, delayMillis);  
    5.  }  

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public final boolean sendMessageDelayed(Message msg, long delayMillis)  
    2.    {  
    3.        if (delayMillis < 0) {  
    4.            delayMillis = 0;  
    5.        }  
    6.        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
    7.    }  

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {  
    2.        MessageQueue queue = mQueue;  
    3.        if (queue == null) {  
    4.            RuntimeException e = new RuntimeException(  
    5.                    this + " sendMessageAtTime() called with no mQueue");  
    6.            Log.w("Looper", e.getMessage(), e);  
    7.            return false;  
    8.        }  
    9.        return enqueueMessage(queue, msg, uptimeMillis);  
    10.    }  

    辗转反则最后调用了sendMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法，我们再来看看此方法：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
    2.        msg.target = this;  
    3.        if (mAsynchronous) {  
    4.            msg.setAsynchronous(true);  
    5.        }  
    6.        return queue.enqueueMessage(msg, uptimeMillis);  
    7.    }  

    enqueueMessage中首先为meg.target赋值为this，【如果大家还记得Looper的loop方法会取出每个msg然后交给msg,target.dispatchMessage(msg)去处理消息】，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。


    现在已经很清楚了Looper会调用prepare()和loop()方法，在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，下面我们赶快去看一看这个方法：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public void dispatchMessage(Message msg) {  
    2.         if (msg.callback != null) {  
    3.             handleCallback(msg);  
    4.         } else {  
    5.             if (mCallback != null) {  
    6.                 if (mCallback.handleMessage(msg)) {  
    7.                     return;  
    8.                 }  
    9.             }  
    10.             handleMessage(msg);  
    11.         }  
    12.     }  

    可以看到，第10行，调用了handleMessage方法，下面我们去看这个方法：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. /** 
    2.    * Subclasses must implement this to receive messages. 
    3.    */  
    4.   public void handleMessage(Message msg) {  
    5.   }  
    6.     
    可以看到这是一个空方法，为什么呢，因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理。

    例如：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. private Handler mHandler = new Handler()  
    2.     {  
    3.         public void handleMessage(android.os.Message msg)  
    4.         {  
    5.             switch (msg.what)  
    6.             {  
    7.             case value:  
    8.                   
    9.                 break;  
    10.   
    11.             default:  
    12.                 break;  
    13.             }  
    14.         };  
    15.     };  

    到此，这个流程已经解释完毕，让我们首先总结一下

    1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

    2、Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。

    3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。

    4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。

    5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

    好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，为啥Handler可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

    3、Handler post

    今天有人问我，你说Handler的post方法创建的线程和UI线程有什么关系？

    其实这个问题也是出现这篇博客的原因之一；这里需要说明，有时候为了方便，我们会直接写如下代码：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. mHandler.post(new Runnable()  
    2.         {  
    3.             @Override  
    4.             public void run()  
    5.             {  
    6.                 Log.e("TAG", Thread.currentThread().getName());  
    7.                 mTxt.setText("yoxi");  
    8.             }  
    9.         });  

    然后run方法中可以写更新UI的代码，其实这个Runnable并没有创建什么线程，而是发送了一条消息，下面看源码：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public final boolean post(Runnable r)  
    2.    {  
    3.       return  sendMessageDelayed(getPostMessage(r), 0);  
    4.    }  
    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. private static Message getPostMessage(Runnable r) {  
    2.       Message m = Message.obtain();  
    3.       m.callback = r;  
    4.       return m;  
    5.   }  

    可以看到，在getPostMessage中，得到了一个Message对象，然后将我们创建的Runable对象作为callback属性，赋值给了此message.

    注：产生一个Message对象，可以new  ，也可以使用Message.obtain()方法；两者都可以，但是更建议使用obtain方法，因为Message内部维护了一个Message池用于Message的复用，避免使用new 重新分配内存。

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public final boolean sendMessageDelayed(Message msg, long delayMillis)  
    2.    {  
    3.        if (delayMillis < 0) {  
    4.            delayMillis = 0;  
    5.        }  
    6.        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
    7.    }  

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {  
    2.        MessageQueue queue = mQueue;  
    3.        if (queue == null) {  
    4.            RuntimeException e = new RuntimeException(  
    5.                    this + " sendMessageAtTime() called with no mQueue");  
    6.            Log.w("Looper", e.getMessage(), e);  
    7.            return false;  
    8.        }  
    9.        return enqueueMessage(queue, msg, uptimeMillis);  
    10.    }  
    最终和handler.sendMessage一样，调用了sendMessageAtTime，然后调用了enqueueMessage方法，给msg.target赋值为handler，最终加入MessagQueue.

    可以看到，这里msg的callback和target都有值，那么会执行哪个呢？

    其实上面已经贴过代码，就是dispatchMessage方法：

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public void dispatchMessage(Message msg) {  
    2.        if (msg.callback != null) {  
    3.            handleCallback(msg);  
    4.        } else {  
    5.            if (mCallback != null) {  
    6.                if (mCallback.handleMessage(msg)) {  
    7.                    return;  
    8.                }  
    9.            }  
    10.            handleMessage(msg);  
    11.        }  
    12.    }  
    第2行，如果不为null，则执行callback回调，也就是我们的Runnable对象。

    好了，关于Looper , Handler , Message 这三者关系上面已经叙述的非常清楚了。

    最后来张图解：


    希望图片可以更好的帮助大家的记忆~~

    4、后话

    其实Handler不仅可以更新UI，你完全可以在一个子线程中去创建一个Handler，然后使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建Handler实例的线程中运行。

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. new Thread()  
    2.         {  
    3.             private Handler handler;  
    4.             public void run()  
    5.             {  
    6.   
    7.                 Looper.prepare();  
    8.                   
    9.                 handler = new Handler()  
    10.                 {  
    11.                     public void handleMessage(android.os.Message msg)  
    12.                     {  
    13.                         Log.e("TAG",Thread.currentThread().getName());  
    14.                     };  
    15.                 };<pre code_snippet_id="445431" snippet_file_name="blog_20140808_19_1943618" name="code" class="java">                               Looper.loop();                                                                                                                              }             </pre>  

    Android不仅给我们提供了异步消息处理机制让我们更好的完成UI的更新，其实也为我们提供了异步消息处理机制代码的参考~~不仅能够知道原理，最好还可以将此设计用到其他的非Android项目中去~~
  • 相关阅读:
    Git 几个常用操作
    Ubuntu16.04安装YouCompleteMe
    常用命令总结
    启动Kernel提示Bad Data CRC
    linux4.15.1编译init/mounts报错
    编译Linux-4.15.1内核时遇到：“error : openssl/bio.h :No such file or folder”
    添加mtdparts引起的问题
    arm-linux-ld:u-boot.lds:1: ignoring invalid character `#' in expression
    smartgit的安装
    ubuntu下安装wine
  • 原文地址：https://www.cnblogs.com/You0/p/5984481.html
Copyright © 2011-2022 走看看