2. 程式人生 > >Muduo網路庫原始碼分析（一） EventLoop事件迴圈（Poller和Channel）

Muduo網路庫原始碼分析（一） EventLoop事件迴圈（Poller和Channel）

阿新 • • 發佈：2019-01-03

從這一篇博文起，我們開始剖析Muduo網路庫的原始碼，主要結合《Linux多執行緒服務端程式設計》和網上的一些學習資料！

（一）TCP網路程式設計的本質：三個半事件

1. 連線的建立，包括服務端接受(accept) 新連線和客戶端成功發起(connect) 連線。TCP 連線一旦建立，客戶端和服務端是平等的，可以各自收發資料。

2. 連線的斷開，包括主動斷開(close 或shutdown) 和被動斷開(read(2) 返回0)。

3. 訊息到達，檔案描述符可讀。這是最為重要的一個事件，對它的處理方式決定了網路程式設計的風格（阻塞還是非阻塞，如何處理分包，應用層的緩衝如何設計等等）。

3.5 訊息傳送完畢，這算半個。對於低流量的服務，可以不必關心這個事件；另外，這裡“傳送完畢”是指將資料寫入作業系統的緩衝區，將由TCP 協議棧負責資料的傳送與重傳，不代表對方已經收到資料。

這其中，最主要的便是第三點： 訊息到達，檔案描述符可讀。下面我們來仔細分析（順便分析訊息傳送完畢）：


（1）訊息到達，檔案可讀：

核心接收-> 網路庫可讀事件觸發--> 將資料從核心轉至應用緩衝區（並且回撥函式OnMessage根據協議判斷是否是完整的資料包，如果不是立即返回）-->如果完整就取出讀走、解包、處理、傳送(read decode compute encode write)

（2）訊息傳送完畢：

應用緩衝區-->核心緩衝區（可全填）--->觸發傳送完成的事件，回撥Onwrite。如果核心緩衝區不足以容納資料（高流量的服務），要把資料追加到應用層傳送緩衝區中核心資料傳送之後，觸發socket

可寫事件，應用層-->核心；當全傳送至核心時，又會回撥Onwrite（可繼續寫）

（二）事件迴圈類圖


EventLoop類：

EventLoop是對Reactor模式的封裝，由於Muduo的併發原型是 Multiple reactors + threadpool  (one loop per thread + threadpool)，所以每個執行緒最多隻能有一個EventLoop物件。EventLoop物件構造的時候，會檢查當前執行緒是否已經建立了其他EventLoop物件，如果已建立，終止程式（LOG_FATAL），EventLoop類的建構函式會記錄本物件所屬執行緒（threadld_

），建立了EventLoop物件的執行緒稱為IO執行緒，其功能是執行事件迴圈（EventLoop：loop），啥也不幹==

下面是簡化版的EventLoop（內部的Poller尚未實現，只是一個框架）

EventLoop.h

#ifndef MUDUO_NET_EVENTLOOP_H
#define MUDUO_NET_EVENTLOOP_H

#include <boost/noncopyable.hpp>
#include <muduo/base/CurrentThread.h>
#include <muduo/base/Thread.h>

namespace muduo
{
namespace net
{
/// Reactor, at most one per thread.
/// This is an interface class, so don't expose too much details.
class EventLoop : boost::noncopyable
{
 public:
  EventLoop();
  ~EventLoop();  // force out-line dtor, for scoped_ptr members.
  /// Loops forever.
  /// Must be called in the same thread as creation of the object.
  void loop();
  void assertInLoopThread()
  {
    if (!isInLoopThread())
    {
      abortNotInLoopThread();
    }
  }
  bool isInLoopThread() const { return threadId_ == CurrentThread::tid(); }

  static EventLoop* getEventLoopOfCurrentThread();

 private:
  void abortNotInLoopThread();
  
  bool looping_; /* atomic */
  const pid_t threadId_;		// 當前物件所屬執行緒ID
};

}
}
#endif  // MUDUO_NET_EVENTLOOP_H
EventLoop.c 
#include <muduo/net/EventLoop.h>
#include <muduo/base/Logging.h>
#include <poll.h>
using namespace muduo;
using namespace muduo::net;

namespace
{
// 當前執行緒EventLoop物件指標
// 執行緒區域性儲存
__thread EventLoop* t_loopInThisThread = 0;
}

EventLoop* EventLoop::getEventLoopOfCurrentThread()
{
  return t_loopInThisThread;
}

EventLoop::EventLoop()
  : looping_(false),
    threadId_(CurrentThread::tid())
{
  LOG_TRACE << "EventLoop created " << this << " in thread " << threadId_;
  // 如果當前執行緒已經建立了EventLoop物件，終止(LOG_FATAL)
  if (t_loopInThisThread)
  {
    LOG_FATAL << "Another EventLoop " << t_loopInThisThread
              << " exists in this thread " << threadId_;
  }
  else
  {
    t_loopInThisThread = this;
  }
}

EventLoop::~EventLoop()
{
  t_loopInThisThread = NULL;
}

// 事件迴圈，該函式不能跨執行緒呼叫
// 只能在建立該物件的執行緒中呼叫
void EventLoop::loop()
{
  assert(!looping_);
  // 斷言當前處於建立該物件的執行緒中
  assertInLoopThread();
  looping_ = true;
  LOG_TRACE << "EventLoop " << this << " start looping";

  ::poll(NULL, 0, 5*1000);

  LOG_TRACE << "EventLoop " << this << " stop looping";
  looping_ = false;
}

void EventLoop::abortNotInLoopThread()
{
  LOG_FATAL << "EventLoop::abortNotInLoopThread - EventLoop " << this
            << " was created in threadId_ = " << threadId_
            << ", current thread id = " <<  CurrentThread::tid();
}

Poller類：

時序圖：



Poller是個抽象類，具體可以是EPollPoller（預設） 或者PollPoller，需要去實現（唯一使用面向物件的一個類）

對於PollPoller來說，存在一個map，用來關聯fd和channel的，我們可以根據fd快速找到對應的channel。一個fd對應一個struct pollfd（pollfd.fd），一個fd 對應一個channel*；這個fd 可以是socket, eventfd, timerfd, signalfd。

Poller的作用是更新IO複用中的channel（IO事件），新增、刪除Channel。我們看一下PollPoller的實現：

PollPoller.h

#ifndef MUDUO_NET_POLLER_POLLPOLLER_H
#define MUDUO_NET_POLLER_POLLPOLLER_H

#include <muduo/net/Poller.h>
#include <map>
#include <vector>

struct pollfd;

namespace muduo
{
namespace net
{

/// IO Multiplexing with poll(2).
class PollPoller : public Poller
{
 public:

  PollPoller(EventLoop* loop);
  virtual ~PollPoller();

  virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels);
  virtual void updateChannel(Channel* channel);
  virtual void removeChannel(Channel* channel);

 private:
  void fillActiveChannels(int numEvents,
                          ChannelList* activeChannels) const;

  typedef std::vector<struct pollfd> PollFdList;
  typedef std::map<int, Channel*> ChannelMap;	// key是檔案描述符，value是Channel*
  PollFdList pollfds_;
  ChannelMap channels_;
};

}
}
#endif  // MUDUO_NET_POLLER_POLLPOLLER_H

PollPoller.c

#include <muduo/net/poller/PollPoller.h>
#include <muduo/base/Logging.h>
#include <muduo/base/Types.h>
#include <muduo/net/Channel.h>
#include <assert.h>
#include <poll.h>

using namespace muduo;
using namespace muduo::net;

PollPoller::PollPoller(EventLoop* loop)
  : Poller(loop)
{
}

PollPoller::~PollPoller()
{
}

Timestamp PollPoller::poll(int timeoutMs, ChannelList* activeChannels)
{
  // XXX pollfds_ shouldn't change
  int numEvents = ::poll(&*pollfds_.begin(), pollfds_.size(), timeoutMs);
  Timestamp now(Timestamp::now());
  if (numEvents > 0)
  {
    LOG_TRACE << numEvents << " events happended";
    fillActiveChannels(numEvents, activeChannels);
  }
  else if (numEvents == 0)
  {
    LOG_TRACE << " nothing happended";
  }
  else
  {
    LOG_SYSERR << "PollPoller::poll()";
  }
  return now;
}

void PollPoller::fillActiveChannels(int numEvents,
                                    ChannelList* activeChannels) const
{
  for (PollFdList::const_iterator pfd = pollfds_.begin();
      pfd != pollfds_.end() && numEvents > 0; ++pfd)
  {
    if (pfd->revents > 0)
    {
      --numEvents;
      ChannelMap::const_iterator ch = channels_.find(pfd->fd);
      assert(ch != channels_.end());
      Channel* channel = ch->second;
      assert(channel->fd() == pfd->fd);
      channel->set_revents(pfd->revents);
      // pfd->revents = 0;
      activeChannels->push_back(channel);
    }
  }
}

void PollPoller::updateChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd() << " events = " << channel->events();
  if (channel->index() < 0)
  {
	// index < 0說明是一個新的通道
    // a new one, add to pollfds_
    assert(channels_.find(channel->fd()) == channels_.end());
    struct pollfd pfd;
    pfd.fd = channel->fd();
    pfd.events = static_cast<short>(channel->events());
    pfd.revents = 0;
    pollfds_.push_back(pfd);
    int idx = static_cast<int>(pollfds_.size())-1;
    channel->set_index(idx);
    channels_[pfd.fd] = channel;
  }
  else
  {
    // update existing one
    assert(channels_.find(channel->fd()) != channels_.end());
    assert(channels_[channel->fd()] == channel);
    int idx = channel->index();
    assert(0 <= idx && idx < static_cast<int>(pollfds_.size()));
    struct pollfd& pfd = pollfds_[idx];
    assert(pfd.fd == channel->fd() || pfd.fd == -channel->fd()-1);
    pfd.events = static_cast<short>(channel->events());
    pfd.revents = 0;
	// 將一個通道暫時更改為不關注事件，但不從Poller中移除該通道
    if (channel->isNoneEvent())
    {
      // ignore this pollfd
	  // 暫時忽略該檔案描述符的事件
	  // 這裡pfd.fd 可以直接設定為-1
      pfd.fd = -channel->fd()-1;	// 這樣子設定是為了removeChannel優化
    }
  }
}

void PollPoller::removeChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd();
  assert(channels_.find(channel->fd()) != channels_.end());
  assert(channels_[channel->fd()] == channel);
  assert(channel->isNoneEvent());
  int idx = channel->index();
  assert(0 <= idx && idx < static_cast<int>(pollfds_.size()));
  const struct pollfd& pfd = pollfds_[idx]; (void)pfd;
  assert(pfd.fd == -channel->fd()-1 && pfd.events == channel->events());
  size_t n = channels_.erase(channel->fd());
  assert(n == 1); (void)n;
  if (implicit_cast<size_t>(idx) == pollfds_.size()-1)
  {
    pollfds_.pop_back();
  }
  else
  {
	// 這裡移除的演算法複雜度是O(1)，將待刪除元素與最後一個元素交換再pop_back
    int channelAtEnd = pollfds_.back().fd;
    iter_swap(pollfds_.begin()+idx, pollfds_.end()-1);
    if (channelAtEnd < 0)
    {
      channelAtEnd = -channelAtEnd-1;
    }
    channels_[channelAtEnd]->set_index(idx);
    pollfds_.pop_back();
  }
}
程式碼中的幾個技巧都在註釋中標出。

Channel類：

Channel是selectable IO channel，負責註冊與響應IO 事件，它不擁有file descriptor。

Channel是Reactor結構中的“事件”，它自始至終都屬於一個EventLoop（一個EventLoop對應多個Channel，處理多個IO），負責一個檔案描述符的IO事件，它包含又檔案描述符fd_，但實際上它不擁有fd_，不用負責將其關閉。在Channel類中儲存這IO事件的型別以及對應的回撥函式，當IO事件發生時，最終會呼叫到Channel類中的回撥函式。Channel類一般不單獨使用，它常常包含在其他類中（Acceptor、Connector、EventLoop、TimerQueue、TcpConnection）使用。Channel類有EventLoop的指標 loop_，通過這個指標可以向EventLoop中添加當前Channel事件。事件型別用events_表示，不同事件型別對應不同回撥函式。

以下兩個都由Channel註冊：

Acceptor是被動連線的抽象--->關注監聽套接字的可讀事件，回撥handleRead。

Connector對主動連線的抽象。

時序圖：


Channel.h

#ifndef MUDUO_NET_CHANNEL_H
#define MUDUO_NET_CHANNEL_H

#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <muduo/base/Timestamp.h>

namespace muduo
{
namespace net
{

class EventLoop;

/// A selectable I/O channel.
/// This class doesn't own the file descriptor.
/// The file descriptor could be a socket,
/// an eventfd, a timerfd, or a signalfd
class Channel : boost::noncopyable
{
 public:
  typedef boost::function<void()> EventCallback;
  typedef boost::function<void(Timestamp)> ReadEventCallback;

  Channel(EventLoop* loop, int fd);
  ~Channel();

  void handleEvent(Timestamp receiveTime);
  void setReadCallback(const ReadEventCallback& cb)
  { readCallback_ = cb; }
  void setWriteCallback(const EventCallback& cb)
  { writeCallback_ = cb; }
  void setCloseCallback(const EventCallback& cb)
  { closeCallback_ = cb; }
  void setErrorCallback(const EventCallback& cb)
  { errorCallback_ = cb; }

  /// Tie this channel to the owner object managed by shared_ptr,
  /// prevent the owner object being destroyed in handleEvent.
  void tie(const boost::shared_ptr<void>&);

  int fd() const { return fd_; }
  int events() const { return events_; }
  void set_revents(int revt) { revents_ = revt; } // used by pollers
  // int revents() const { return revents_; }
  bool isNoneEvent() const { return events_ == kNoneEvent; }

  void enableReading() { events_ |= kReadEvent; update(); }
  // void disableReading() { events_ &= ~kReadEvent; update(); }
  void enableWriting() { events_ |= kWriteEvent; update(); }
  void disableWriting() { events_ &= ~kWriteEvent; update(); }
  void disableAll() { events_ = kNoneEvent; update(); }
  bool isWriting() const { return events_ & kWriteEvent; }

  // for Poller
  int index() { return index_; }
  void set_index(int idx) { index_ = idx; }

  // for debug
  string reventsToString() const;

  void doNotLogHup() { logHup_ = false; }

  EventLoop* ownerLoop() { return loop_; }
  void remove();

 private:
  void update();
  void handleEventWithGuard(Timestamp receiveTime);

  static const int kNoneEvent;
  static const int kReadEvent;
  static const int kWriteEvent;

  EventLoop* loop_;			// 所屬EventLoop
  const int  fd_;			// 檔案描述符，但不負責關閉該檔案描述符
  int        events_;		// 關注的事件
  int        revents_;		// poll/epoll返回的事件
  int        index_;		// used by Poller.表示在poll的事件陣列中的序號
  bool       logHup_;		// for POLLHUP

  boost::weak_ptr<void> tie_;
  bool tied_;
  bool eventHandling_;		// 是否處於處理事件中
  ReadEventCallback readCallback_;
  EventCallback writeCallback_;
  EventCallback closeCallback_;
  EventCallback errorCallback_;
};

}
}
#endif  // MUDUO_NET_CHANNEL_H
Channel.c 
#include <muduo/base/Logging.h>
#include <muduo/net/Channel.h>
#include <muduo/net/EventLoop.h>
#include <sstream>
#include <poll.h>

using namespace muduo;
using namespace muduo::net;

const int Channel::kNoneEvent = 0;
const int Channel::kReadEvent = POLLIN | POLLPRI;
const int Channel::kWriteEvent = POLLOUT;

Channel::Channel(EventLoop* loop, int fd__)
  : loop_(loop),
    fd_(fd__),
    events_(0),
    revents_(0),
    index_(-1),
    logHup_(true),
    tied_(false),
    eventHandling_(false)
{
}

Channel::~Channel()
{
  assert(!eventHandling_);
}

void Channel::tie(const boost::shared_ptr<void>& obj)
{
  tie_ = obj;
  tied_ = true;
}

void Channel::update()
{
  loop_->updateChannel(this);
}

// 呼叫這個函式之前確保呼叫disableAll
void Channel::remove()
{
  assert(isNoneEvent());
  loop_->removeChannel(this);
}

void Channel::handleEvent(Timestamp receiveTime)
{
  boost::shared_ptr<void> guard;
  if (tied_)
  {
    guard = tie_.lock();
    if (guard)
    {
      handleEventWithGuard(receiveTime);
    }
  }
  else
  {
    handleEventWithGuard(receiveTime);
  }
}

void Channel::handleEventWithGuard(Timestamp receiveTime)
{
  eventHandling_ = true;
  if ((revents_ & POLLHUP) && !(revents_ & POLLIN))
  {
    if (logHup_)
    {
      LOG_WARN << "Channel::handle_event() POLLHUP";
    }
    if (closeCallback_) closeCallback_();
  }

  if (revents_ & POLLNVAL)
  {
    LOG_WARN << "Channel::handle_event() POLLNVAL";
  }

  if (revents_ & (POLLERR | POLLNVAL))
  {
    if (errorCallback_) errorCallback_();
  }
  if (revents_ & (POLLIN | POLLPRI | POLLRDHUP))
  {
    if (readCallback_) readCallback_(receiveTime);
  }
  if (revents_ & POLLOUT)
  {
    if (writeCallback_) writeCallback_();
  }
  eventHandling_ = false;
}

string Channel::reventsToString() const
{
  std::ostringstream oss;
  oss << fd_ << ": ";
  if (revents_ & POLLIN)
    oss << "IN ";
  if (revents_ & POLLPRI)
    oss << "PRI ";
  if (revents_ & POLLOUT)
    oss << "OUT ";
  if (revents_ & POLLHUP)
    oss << "HUP ";
  if (revents_ & POLLRDHUP)
    oss << "RDHUP ";
  if (revents_ & POLLERR)
    oss << "ERR ";
  if (revents_ & POLLNVAL)
    oss << "NVAL ";

  return oss.str().c_str();
}
這三個類之間的關係不難理解，其實本質就是一個Poll/Epoll，只不過進行了更高的抽象後劃分出來的這些類，重點理解部落格開頭的那張類圖即可。

參考：

《Muduo使用手冊》

《Linux多執行緒服務端程式設計》


相關推薦

Muduo網路庫原始碼分析（一） EventLoop事件迴圈（Poller和Channel）

從這一篇博文起，我們開始剖析Muduo網路庫的原始碼，主要結合《Linux多執行緒服務端程式設計》和網上的一些學習資料！ （一）TCP網路程式設計的本質：三個半事件 1. 連線的建立，包括服務端接受(accept) 新連線和客戶端成功發起(connect) 連線。TCP 連

Muduo網路庫原始碼分析（四）EventLoopThread和EventLoopThreadPool的封裝

muduo的併發模型為one loop per thread+ threadpool。為了方便使用，muduo封裝了EventLoop和Thread為EventLoopThread，為了方便使用執行緒

Muduo網路庫原始碼分析（二） 定時器TimeQueue，Timer,TimerId

首先，我們先要明白為什麼需要設計這樣一個定時器類？ 在開發Linux網路程式時，通常需要維護多個定時器，如維護客戶端心跳時間、檢查多個數據包的超時重傳等。如果採用linux的SIGALARM訊號實現，則會帶來較大的系統開銷，且不便於管理。 Muduo 的 Timer

Muduo網路庫原始碼分析（三）執行緒間使用eventfd通訊和EventLoop::runInLoop系列函式

先說第一點，執行緒（程序）間通訊有很多種方式（pipe,socketpair），為什麼這裡選擇eventfd？ eventfd 是一個比 pipe 更高效的執行緒間事件通知機制，一方面它比 pipe

【 專欄 】- muduo網路庫原始碼分析

muduo網路庫原始碼分析 muduo是基於Reactor模式的C++網路庫，採用Reactor + 執行緒池的方法提高併發性。內部對於事件驅動，執行緒池，定時器，io複用的設計都非常值得學習。設計技巧對C++程式碼風格有很大的幫

Muduo 網路庫原始碼分析 之 關鍵技術點總結

最近又把muduo網路庫仔細研究了一遍，收穫良多。本文將對muduo中的設計思想以及關鍵的技術細節進行總結和分析，當然由於篇幅的原因這裡更多的是對關鍵技術的簡略提及，具體細節還需要讀者自己去查詢學習資料。 muduo/base Date類 日期類的封裝，

libevent高效能網路庫原始碼分析——事件(event)及其介面（三）

libevent的結構 event結構 // include/event2/event_struct.h struct event { TAILQ_ENTRY(event) ev_active_next; // 已就緒的事件連結串列

muduo網路庫原始碼閱讀Step by Step

Posted on: Nov 26 2015 Categories: muduo C++ Tags: muduo 一般寫服務端程式都需要有一個稱手的網路庫來幫我們處理瑣碎的網路通訊細節，比如連線的建立、關閉，讀取資料，傳送資料，接收、傳送緩衝區的管理等，常用的C/C++網路庫有libevent，

muduo網路庫原始碼學習————執行緒池實現

muduo庫裡面的執行緒池是固定執行緒池，即建立的執行緒池裡面的執行緒個數是一定的，不是動態的。執行緒池裡面一般要包含執行緒佇列還有任務佇列，外部程式將任務存放到執行緒池的任務佇列中，執行緒池中的執行緒佇列執行任務，也是一種生產者和消費者模型。muduo庫中的執

muduo網路庫原始碼解析 七

這一章節，我們來分析多執行緒TcpServer，首先分析muduo one loop per thread的基石——EventLoopThread class，EventLoopThread會啟動自己的執行緒，並在其中執行EventLoop::loop()，關鍵的start

muduo網路庫原始碼解析 五

TcpConnection用來管理連線，包括連線的狀態、訊息的處理（發、收），該類是muduo中唯一一個實用shared_ptr來進行管理的類，也是唯一繼承enable_shared_from_this的類，這源於TcpConnection類的模糊的生命期。在本章的結尾我們

Redis網路庫原始碼分析(1)之介紹篇

一、前言 Redis網路庫是一個單執行緒EPOLL模型的網路庫，和Memcached使用的libevent相比，它沒有那麼龐大，程式碼一共2000多行，因此比較容易分析。其實網上已經有非常多有關這個網

Redis網路庫原始碼分析(3)之ae.c

一、aeCreateEventLoop & aeCreateFileEvent 上一篇文章中，我們已經將伺服器啟動，只是其中有些細節我們跳過了，比如aeCreateEventLoop函式到底做了什麼？ 接下來我們要分析ae.c檔案，它是整個Redis

muduo網路庫原始碼解析 四

這一章節我們首先來解析用到的socket的基礎函式： 1、位元組序轉換函式封裝為HostToNetwork16、HostToNetwork32類似命名，原函式為htons、htonl，封裝後方便記憶與書寫，標頭檔案<netinet/in.h> 2、地址轉換函式t

Just Too Lucky（一個數能被其各位的和整除）

題目連結https://vjudge.net/problem/Gym-100623J 題目大意：求1-n中，有多少個數，可以被其各位的和整除 n<=1e12   設x為數位和 x的範圍為[1,108] 也就是說要讓一個數n mod x = 0 &nbs

caioj1063·動態規劃入門（一維一邊推1：美元和馬克）

1063:動態規劃入門（一維一邊推1：美元和馬克） 時間限制: 1 Sec 記憶體限制: 128 MB 題目描述 【問題描述】 今天6:00起床，我轉身發現枕頭邊有100美元。 出門的時候發現門口有家冰淇淋店，拉了很長的橫幅：“今天100美元和4

Swoole 原始碼分析——Server模組之TaskWorker事件迴圈

swManager_start 建立程序流程 task_worker 程序的建立可以分為三個步驟：swServer_create_task_worker 申請所需的記憶體、swTaskWorker_init 初始化各個屬性、swProcessPool_start 建立程序 int swManager_

muduo網路庫學習（一）對io複用的封裝Poller，面向物件與基於物件

高效併發的網路框架大多離不開io多路複用函式，Linux下有三種 select poll epoll 關於三者的區別可以參考 linux網路程式設計—–幾種伺服器模型及io多路複用函式 前段時間看Libevent原始碼時也學習過對epoll/poll/

Muduo庫原始碼分析（8）：單例模式實現

單例模式 保證一個類只有一個例項，並提供一個訪問它的全域性訪問點 Muduo庫實現單例模式的思想： 通過pthread_once在多個執行緒中只會初始化一次的特性實現的執行緒安全的單例模式

一個酷炫的button變化動畫開源庫原始碼分析—Android morph Button（一）

最近很是喜愛一些酷炫的動畫效果，特意在github上找了一些，看看他們是怎麼做到的，做個分析，順便可以對自定義控制元件和動畫有進一步的認識。 先來看下這個庫中button的變化效果是什麼樣的： 是不是很酷炫，而且中間的變化過程很舒服，沒