Undefined

常用算法题c++解析

Sat, 20 Apr 2019 00:00:00 +0000

单链表的反转

定义3个结点，返回反转后的头结点

ListNode* ReverseList(ListNode* pHead) {
    ListNode* pReversedHead = NULL;
    ListNode* pNode = pHead;
    ListNode* pPrev = NULL;

    while (pNode != NULL) {
        ListNode* pNext = pNode->m_pNext;
        if (pNext == NULL)
            pReversedHead = pNode;

        pNode->m_pNext = pPrev;
        pPrev = pNode;
        pNode = pNext;
    }
    return pReversedHead;
}

8皇后算法(回溯法)

int n=8;
int total=0;
int *c=new int(n);

bool is_ok(int row){
	for(int j=0;j!=row;j++){
		//同一行 两边对角线  不符合条件
		if(c[row]==c[j] || row-c[row]==j-c[j] || row+c[row]==j+c[j])
		return false;
	}
	return true;
}

void queen(int row){
	//符合条件就累加一次
	if(row==n)
		total++;
	else
		for(int col=0;col!=n;col++){
			//记录每次的行号。
			c[row]=col;
			if(is_ok(row)) 
				queen(row+1); //当前棋子符合条件，计算下一个棋子
			else  //不符合就记录下一个行号 ,啥也不干
				;
	}
}

int main(){
	queen(0);
	cout<<total;
	return 1;
}

LRU简易实现(一)

Mon, 08 Apr 2019 00:00:00 +0000

链表实现

考虑头尾结点的特殊情况，不要遗漏。

查询还是循环查询(log(N)),考虑到性能的话，可以采用哈希跟双端链表组合实现。

typedef struct DlistNode      //双向链表中每一个节点
{				  	
	struct DlistNode *prev;   //节点前项指针
	struct DlistNode *next;   //节点后项指针
	int    data;              //数据
}stDlistNode;

typedef struct Dlisthead      //定义链表总体
{
	int 	size;             //链表长度
	stDlistNode *head;        //头指针
	stDlistNode *tail;        //尾部指针
}stDlistHead;

void dlist_init(stDlistHead *dlist)		//链表初始化
{
	dlist->size = 0;
	dlist->head = NULL;
	dlist->tail = NULL;
	return;
}

void dlist_destory(stDlistHead *dlist)		//删除链表
{
	stDlistNode *pNode = NULL;
	
	while(dlist->size > 0)
	{
		pNode = dlist->head;
		dlist->head = dlist->head->next;
		free(pNode);
		dlist->size--;
	}

	memset(dlist,0,sizeof(stDlistHead));

	return;
}

int dlist_insert_head(stDlistHead *dlist,stDlistNode *pNode,int data)		//插入头结点，操作的链表，操作的节点，数据
{
   if(pNode == NULL)		//当只传递一个数据时
   {
		pNode = (stDlistNode *)malloc(sizeof(stDlistNode));		//新建节点，为节点分配空间（malloc（）可能需要#include<malloc.h>）
		if (pNode == NULL)
		{
			return -1;
		}
	}

	pNode->data = data;			
	pNode->prev = NULL;
	pNode->next = NULL;

	if (dlist->size == 0)		//如果链表长度为0，即链表当前无节点，
	{
		dlist->head = pNode;
		dlist->tail = pNode;
	}
	else                           //如果链表已有节点，则令新插入节点为头节点
	{
		pNode->next = dlist->head;
		dlist->head->prev = pNode;
		dlist->head = pNode;			
	}

	dlist->size++;		//每成功调用一次，链表长度+1
	return 0;
}

stDlistNode * dlist_remove_tail(stDlistHead *dlist)		//删除尾部节点,并返回删除节点
{
	stDlistNode *pNode = NULL;

	if(dlist->size == 0)
	{
		return NULL;
	}

	pNode = dlist->tail;
	if(dlist->size > 1)
	{
		dlist->tail = dlist->tail->prev;
		dlist->tail->next = NULL;
	}
	else
	{
		dlist->head = NULL;
		dlist->tail = NULL;
	}
	dlist->size--;
	return pNode;
}

void dlist_remove_node(stDlistHead * dlist,stDlistNode *pNode) 		//删除指定节点
{
	if ((dlist == NULL)||(pNode == NULL))
	{
		return;
	}

	if (dlist->head == pNode)
	{
		dlist->head = dlist->head->next;
	}
	else if (dlist->tail == pNode)
	{
		dlist->tail = pNode->prev;

		dlist->tail->next = NULL;
	}
	else
	{
		pNode->prev->next = pNode->next;
		pNode->next->prev = pNode->prev;
	}
	dlist->size--;
	pNode->prev = NULL;
	pNode->next = NULL;
	
	if (dlist->size == 0)
	{
		memset(dlist,0,sizeof(stDlistHead)); 		//将dlist占用内存块的所有值置为0，也就是清空head,tail指针内容
	}

	return;
}
stDlistNode * dlist_search(stDlistHead * dlist,int data) 		//根据值搜索节点，并返回
{
	stDlistNode *pNode = dlist->head;
	while(pNode != NULL)
	{
		if (pNode->data == data)
		{
			return pNode;
		}
		pNode = pNode->next;

	}
	return NULL;
}

void dlist_dump(stDlistHead *dlist)		//显示链表中的数据
{
	int no = 0;
	stDlistNode *pNode = dlist->head;
	while(pNode != NULL)		
	{
		printf("\r\n [%d] = %d",no++,pNode->data);
		pNode = pNode->next;		//将pNode的下一个节点赋值给pNode，推进循环
	}

	return;
}


void Lru_dlist(stDlistHead *dlist,int data) 		//LRU（最近最少使用）缓存淘汰算法
{
	stDlistNode *pNode = NULL;

	pNode = dlist_search(dlist,data);		
	if (pNode != NULL) 				//如果在链表中找到这个值，则删除储存这个值的节点，之后吧这个节点放在头部
	{
		dlist_remove_node(dlist,pNode);
	}
	else if(dlist->size >= 4)			//没在链表中找到，且链表长度大于4，则从链表中删除尾部节点，将新数据放在头部
	{
		pNode = dlist_remove_tail(dlist);

	}
	
	dlist_insert_head(dlist ,,pNodedata);

	return;
}

int main()
{
	stDlistHead dlist = {0};
	stDlistNode * pNode = NULL;

	dlist_init(&dlist);

	printf("\r\n inset 1,2,3");
	dlist_insert_head(&dlist,NULL,1);
	dlist_insert_head(&dlist,NULL,2);
	dlist_insert_head(&dlist,NULL,3);

	dlist_dump(&dlist);

	pNode = dlist_remove_tail(&dlist);
	if(pNode != NULL)
	{
		printf("\r\n remove %d",pNode->data);
	}
	dlist_insert_head(&dlist,pNode,4);
	dlist_dump(&dlist);

	Lru_dlist(&dlist,5);
	dlist_dump(&dlist);
	Lru_dlist(&dlist,6);
	dlist_dump(&dlist);
	Lru_dlist(&dlist,7);
	dlist_dump(&dlist);
	Lru_dlist(&dlist,5);
	dlist_dump(&dlist);



	while(dlist.size > 0)
	{
		pNode = dlist_remove_tail(&dlist);
		if(pNode != NULL)
		{ 
			printf("\r\n remove %d",pNode->data);
			free (pNode);
		}
	}

	return 0;
}
	

muduo分析

Fri, 17 Aug 2018 00:00:00 +0000

1.muduo编译安装

Github源码目录: https://github.com/chenshuo/muduo

编译muduo遇见的报错可以在github上的issue上面查找。一般都能顺利解决,我遇到的就是没有安装boost-dev.

centos7系统执行: sudo yum install boost-dev

2.截取流程图

图片截取自《Linux多线程服务端编程：使用muduo C++网络库》

3.源码摘录

摘录一个examples里面的pingpong为例

server.cc 设置回调，开启服务

void onConnection(const TcpConnectionPtr& conn)
{
  if (conn->connected())
  {
    conn->setTcpNoDelay(true);
  }
}

void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)
{
  conn->send(buf);
}

int main(int argc, char* argv[])
{
  if (argc < 4)
  {
    fprintf(stderr, "Usage: server <address> <port> <threads>\n");
  }
  else
  {
    LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
    Logger::setLogLevel(Logger::WARN);

    const char* ip = argv[1];
    uint16_t port = static_cast<uint16_t>(atoi(argv[2]));
    InetAddress listenAddr(ip, port);
    int threadCount = atoi(argv[3]);

    EventLoop loop;

    TcpServer server(&loop, listenAddr, "PingPong");

    server.setConnectionCallback(onConnection);
    server.setMessageCallback(onMessage);

    if (threadCount > 1)
    {
      server.setThreadNum(threadCount);
    }

    server.start();

    loop.loop();
  }
}

main函数中新建TcpServer 对象，TcpServer构造函数会新建Acceptor对象。Acceptor构造函数中定义了channel对象。channel中包含EventLoop。EventLoop里面根据poller来获取各种事件。

代码可以从main入手，从下往上看。这里便于理清原理，倒叙表达

1.poller 2种模式之epoll

fillActiveChannels(numEvents, activeChannels);

channel->set_revents(events_[i].events);

EPollPoller::EPollPoller(EventLoop* loop)
  : Poller(loop),
    epollfd_(::epoll_create1(EPOLL_CLOEXEC)),
    events_(kInitEventListSize)
{
  if (epollfd_ < 0)
  {
    LOG_SYSFATAL << "EPollPoller::EPollPoller";
  }
}

EPollPoller::~EPollPoller()
{
  ::close(epollfd_);
}
Timestamp EPollPoller::poll(int timeoutMs, ChannelList* activeChannels)
{
  LOG_TRACE << "fd total count " << channels_.size();
  int numEvents = ::epoll_wait(epollfd_,
                               &*events_.begin(),
                               static_cast<int>(events_.size()),
                               timeoutMs);
  int savedErrno = errno;
  Timestamp now(Timestamp::now());
  if (numEvents > 0)
  {
    LOG_TRACE << numEvents << " events happened";
    fillActiveChannels(numEvents, activeChannels);
    if (implicit_cast<size_t>(numEvents) == events_.size())
    {
      events_.resize(events_.size()*2);
    }
  }
  else if (numEvents == 0)
  {
    LOG_TRACE << "nothing happened";
  }
  else
  {
    // error happens, log uncommon ones
    if (savedErrno != EINTR)
    {
      errno = savedErrno;
      LOG_SYSERR << "EPollPoller::poll()";
    }
  }
  return now;
}



Poller* Poller::newDefaultPoller(EventLoop* loop)
{
  if (::getenv("MUDUO_USE_POLL"))
  {
    return new PollPoller(loop);
  }
  else
  {
    return new EPollPoller(loop);
  }
}
void EPollPoller::fillActiveChannels(int numEvents,
                                     ChannelList* activeChannels) const
{
  assert(implicit_cast<size_t>(numEvents) <= events_.size());
  for (int i = 0; i < numEvents; ++i)
  {
    Channel* channel = static_cast<Channel*>(events_[i].data.ptr);
#ifndef NDEBUG
    int fd = channel->fd();
    ChannelMap::const_iterator it = channels_.find(fd);
    assert(it != channels_.end());
    assert(it->second == channel);
#endif
    channel->set_revents(events_[i].events);
    activeChannels->push_back(channel);
  }
}

2.EventLoop 获取各种事件

poller_(Poller::newDefaultPoller(this))

pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);

currentActiveChannel_->handleEvent(pollReturnTime_);

EventLoop::EventLoop()
  : looping_(false),
    quit_(false),
    eventHandling_(false),
    callingPendingFunctors_(false),
    iteration_(0),
    threadId_(CurrentThread::tid()),
    poller_(Poller::newDefaultPoller(this)),
    timerQueue_(new TimerQueue(this)),
    wakeupFd_(createEventfd()),
    wakeupChannel_(new Channel(this, wakeupFd_)),
    currentActiveChannel_(NULL)
{
  LOG_DEBUG << "EventLoop created " << this << " in thread " << threadId_;
  if (t_loopInThisThread)
  {
    LOG_FATAL << "Another EventLoop " << t_loopInThisThread
              << " exists in this thread " << threadId_;
  }
  else
  {
    t_loopInThisThread = this;
  }
  wakeupChannel_->setReadCallback(
      boost::bind(&EventLoop::handleRead, this));
  // we are always reading the wakeupfd
  wakeupChannel_->enableReading();
}



void EventLoop::loop()
{
  assert(!looping_);
  assertInLoopThread();
  looping_ = true;
  quit_ = false;  // FIXME: what if someone calls quit() before loop() ?
  LOG_TRACE << "EventLoop " << this << " start looping";

  while (!quit_)
  {
    activeChannels_.clear();
    pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);
    ++iteration_;
    if (Logger::logLevel() <= Logger::TRACE)
    {
      printActiveChannels();
    }
    // TODO sort channel by priority
    eventHandling_ = true;
    for (ChannelList::iterator it = activeChannels_.begin();
        it != activeChannels_.end(); ++it)
    {
      currentActiveChannel_ = *it;
      currentActiveChannel_->handleEvent(pollReturnTime_);
    }
    currentActiveChannel_ = NULL;
    eventHandling_ = false;
    doPendingFunctors();
  }

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

3.channel 分发事件根据EventLoop

revents_ 在epoll中已经设置

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;
  LOG_TRACE << reventsToString();
  if ((revents_ & POLLHUP) && !(revents_ & POLLIN))
  {
    if (logHup_)
    {
      LOG_WARN << "fd = " << fd_ << " Channel::handle_event() POLLHUP";
    }
    if (closeCallback_) closeCallback_();
  }

  if (revents_ & POLLNVAL)
  {
    LOG_WARN << "fd = " << fd_ << " 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;
}

4.Acceptor

loop_(loop),

acceptChannel_(loop, acceptSocket_.fd()),

acceptChannel_.setReadCallback(boost::bind(&Acceptor::handleRead, this));

Acceptor::Acceptor(EventLoop* loop, const InetAddress& listenAddr, bool reuseport)
  : loop_(loop),
    acceptSocket_(sockets::createNonblockingOrDie(listenAddr.family())),
    acceptChannel_(loop, acceptSocket_.fd()),
    listenning_(false),
    idleFd_(::open("/dev/null", O_RDONLY | O_CLOEXEC))
{
  assert(idleFd_ >= 0);
  acceptSocket_.setReuseAddr(true);
  acceptSocket_.setReusePort(reuseport);
  acceptSocket_.bindAddress(listenAddr);
  acceptChannel_.setReadCallback(
      boost::bind(&Acceptor::handleRead, this));
}



void Acceptor::handleRead()
{
  loop_->assertInLoopThread();
  InetAddress peerAddr;
  //FIXME loop until no more
  int connfd = acceptSocket_.accept(&peerAddr);
  if (connfd >= 0)
  {
    // string hostport = peerAddr.toIpPort();
    // LOG_TRACE << "Accepts of " << hostport;
    if (newConnectionCallback_)
    {
      newConnectionCallback_(connfd, peerAddr);
    }
    else
    {
      sockets::close(connfd);
    }
  }
  else
  {
    LOG_SYSERR << "in Acceptor::handleRead";
    // Read the section named "The special problem of
    // accept()ing when you can't" in libev's doc.
    // By Marc Lehmann, author of libev.
    if (errno == EMFILE)
    {
      ::close(idleFd_);
      idleFd_ = ::accept(acceptSocket_.fd(), NULL, NULL);
      ::close(idleFd_);
      idleFd_ = ::open("/dev/null", O_RDONLY | O_CLOEXEC);
    }
  }
}

5.TcpServer

acceptor_(new Acceptor(loop, listenAddr, option == kReusePort)),

ioLoop->runInLoop(boost::bind(&TcpConnection::connectEstablished, conn));

tcpserver 在得到⌈ 新连接newConnection以后，会新建一个 TcpConnection ⌋来处理后续协议报文的发送接收

TcpServer::TcpServer(EventLoop* loop,
                     const InetAddress& listenAddr,
                     const string& nameArg,
                     Option option)
  : loop_(CHECK_NOTNULL(loop)),
    ipPort_(listenAddr.toIpPort()),
    name_(nameArg),
    acceptor_(new Acceptor(loop, listenAddr, option == kReusePort)),
    threadPool_(new EventLoopThreadPool(loop, name_)),
    connectionCallback_(defaultConnectionCallback),
    messageCallback_(defaultMessageCallback),
    nextConnId_(1)
{
  acceptor_->setNewConnectionCallback(
      boost::bind(&TcpServer::newConnection, this, _1, _2));
}



void TcpServer::newConnection(int sockfd, const InetAddress& peerAddr)
{
  loop_->assertInLoopThread();
  EventLoop* ioLoop = threadPool_->getNextLoop();
  char buf[64];
  snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
  ++nextConnId_;
  string connName = name_ + buf;

  LOG_INFO << "TcpServer::newConnection [" << name_
           << "] - new connection [" << connName
           << "] from " << peerAddr.toIpPort();
  InetAddress localAddr(sockets::getLocalAddr(sockfd));
  // FIXME poll with zero timeout to double confirm the new connection
  // FIXME use make_shared if necessary
  TcpConnectionPtr conn(new TcpConnection(ioLoop,
                                          connName,
                                          sockfd,
                                          localAddr,
                                          peerAddr));
  connections_[connName] = conn;
  conn->setConnectionCallback(connectionCallback_);
  conn->setMessageCallback(messageCallback_);
  conn->setWriteCompleteCallback(writeCompleteCallback_);
  conn->setCloseCallback(
      boost::bind(&TcpServer::removeConnection, this, _1)); // FIXME: unsafe
  ioLoop->runInLoop(boost::bind(&TcpConnection::connectEstablished, conn));
}


void TcpServer::start()
{
  if (started_.getAndSet(1) == 0)
  {
    threadPool_->start(threadInitCallback_);

    assert(!acceptor_->listenning());
    loop_->runInLoop(
        boost::bind(&Acceptor::listen, get_pointer(acceptor_)));
  }
}

6.TcpConnection

注册各种IO事件

TcpConnection::TcpConnection(EventLoop* loop,
                             const string& nameArg,
                             int sockfd,
                             const InetAddress& localAddr,
                             const InetAddress& peerAddr)
  : loop_(CHECK_NOTNULL(loop)),
    name_(nameArg),
    state_(kConnecting),
    reading_(true),
    socket_(new Socket(sockfd)),
    channel_(new Channel(loop, sockfd)),
    localAddr_(localAddr),
    peerAddr_(peerAddr),
    highWaterMark_(64*1024*1024)
{
  channel_->setReadCallback(
      boost::bind(&TcpConnection::handleRead, this, _1));
  channel_->setWriteCallback(
      boost::bind(&TcpConnection::handleWrite, this));
  channel_->setCloseCallback(
      boost::bind(&TcpConnection::handleClose, this));
  channel_->setErrorCallback(
      boost::bind(&TcpConnection::handleError, this));
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this
            << " fd=" << sockfd;
  socket_->setKeepAlive(true);
}

7.main使用

EventLoop loop;

TcpServer server(&loop, listenAddr, "PingPong");

server.start();

loop.loop();

void onConnection(const TcpConnectionPtr& conn)
{
  if (conn->connected())
  {
    conn->setTcpNoDelay(true);
  }
}

void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp)
{
  conn->send(buf);
}

int main(int argc, char* argv[])
{
  if (argc < 4)
  {
    fprintf(stderr, "Usage: server <address> <port> <threads>\n");
  }
  else
  {
    LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
    Logger::setLogLevel(Logger::WARN);

    const char* ip = argv[1];
    uint16_t port = static_cast<uint16_t>(atoi(argv[2]));
    InetAddress listenAddr(ip, port);
    int threadCount = atoi(argv[3]);

    EventLoop loop;

    TcpServer server(&loop, listenAddr, "PingPong");

    server.setConnectionCallback(onConnection);
    server.setMessageCallback(onMessage);

    if (threadCount > 1)
    {
      server.setThreadNum(threadCount);
    }

    server.start();

    loop.loop();
  }
}

项目流程(1)

Fri, 27 Jul 2018 00:00:00 +0000

1.启动程序

1.1 开启单线程接受用户请求

//开启一个线程 获取是否有用户连接
g_App.ptrSelectorThread = new commonnet::SelectorThread(g_App.ptrTimer);

//开启任务 处理任务 handleRequest
RequestHandler requestHandler; 

g_App.ptrServer = new commonutil::MWThreadServer(ptrProperties->getProperty("Local.AllIP"),
				 ptrProperties->getPropertyAsInt("tfb_usermgr.Port"),
				 10,
				 g_App.ptrSelectorThread,
				 &requestHandler);
				 
g_App.ptrServer->startWork(); //开始工作 处理任务 
g_App.ptrServer->join(); //等待信号停止任务
g_App.ptrSelectorThread->destroy(); //停止接单
g_App.ptrTimer->destroy();
g_App.ptrSelectorThread->joinWithThread();				 
				 

1.2 监听端口以及工作线程处理任务

//(new commonnet::TcpAcceptor(strIP, nPort,10)  新建一个tcp连接获取消息，
//参数10为 listen参数。(::listen(fd, backlog) == SOCKET_ERROR)
//服务器监听时，在每次处理一个客户端的连接时是需要一定时间的，这个时间非常的短(也许只有1ms 或者还不到)，
//但这个时间还是存在的。而这个backlog 存在的意义就是：在这段时间里面除了第一个连接请求是正在进行处理以外，
//其他的连接请求都在请求队列中等待，而如果超过了队列的最大等待个数时，其他的请求将被忽略或者将不会被处理。

commonutil::MWThreadServer::MWThreadServer(const std::string &strIP, int nPort, int nThreads, commonnet::SelectorThreadPtr &selector, Handler *handler)
        :m_ptrListenAcceptor(new commonnet::TcpAcceptor(strIP, nPort,10)),
        m_ptrSelectorThread(selector),
        m_handler(handler),
        m_nThreads(nThreads),
        m_vecWorkerThreadPtr(nThreads),
        m_vecWorkerThreadControl(nThreads),
        m_bContinue(false),
        m_nWaitCount(0)
{
        m_ptrListenAcceptor->listen();
        commonnet::SocketReadyCallbackPtr ptrCallback = new ListenHandler(m_ptrListenAcceptor, m_ptrSelectorThread, this);
		//线程注册到 底层 监听 //当listen返回时，会调用 ptrCallback 也就是 ListenHandler的socketReady
        m_ptrSelectorThread->_register(m_ptrListenAcceptor->fd(), ptrCallback, commonnet::NeedRead, 0);
}

//startWork在main函数主动调用
void commonutil::MWThreadServer::startWork()
{
        m_bContinue = true;
        for (int i = 0; i < m_nThreads; ++i) {
				//开启工作线程，处理客户端的请求
                WorkerThreadPtr ptrWorkerThread = new WorkerThread(i, this, m_handler);
                m_vecWorkerThreadPtr[i] = ptrWorkerThread;
                m_vecWorkerThreadControl[i] = ptrWorkerThread->start();
        }

}
//添加消息保存 这个调用在 ClientHandler中
void commonutil::MWThreadServer::PushPackage(const commonnet::TransceiverPtr& ptrTransceiver, const commonnet::BasicStreamPtr& ptrBasicStream)
{
        commonutil::Monitor<commonutil::Mutex>::Lock autolock(m_monDataItem);
        commonnet::TransceiverBasicStream data;
        data.ptrTransceiver = ptrTransceiver;
        data.ptrBasicStream = ptrBasicStream;

        m_lstTransceiverBasicStreamPtr.push_back(data);

        if (m_nWaitCount > 0) {
                m_monDataItem.notify();
        }
}
//消费消息  注意加锁控制 这个调用在WorkerThread
bool commonutil::MWThreadServer::PopPackage(commonnet::TransceiverPtr& ptrTransceiver, commonnet::BasicStreamPtr& ptrBasicStream)
{
        while (m_bContinue) {
                commonutil::Monitor<commonutil::Mutex>::Lock autolock(m_monDataItem);
                if (m_lstTransceiverBasicStreamPtr.size() > 0) {
                        commonnet::TransceiverBasicStream data = m_lstTransceiverBasicStreamPtr.front();
                        ptrTransceiver = data.ptrTransceiver;
                        ptrBasicStream = data.ptrBasicStream;
                        m_lstTransceiverBasicStreamPtr.pop_front();
                        return true;
                }

                ++m_nWaitCount;
                m_monDataItem.wait();
                --m_nWaitCount;
        }
        return false;
}

1.3 listen之后的accept功能，保存用户数据跟连接标识符

commonutil::MWThreadServer::ListenHandler::ListenHandler(const commonnet::AcceptorPtr &ptrAcceptor, 
		   const commonnet::SelectorThreadPtr & ptrSelectorThread,
		   commonutil::MWThreadServer *server)
:m_ptrAcceptor(ptrAcceptor),
m_ptrSelectorThread(ptrSelectorThread),
m_server(server)
{

}

commonnet::SocketStatus commonutil::MWThreadServer::ListenHandler::socketReady()
{		
		//listen后直接 accept
        commonnet::TransceiverPtr ptrTransceiver = m_ptrAcceptor->accept();
        commonnet::SocketReadyCallbackPtr ptrCallback = new ClientHandler(ptrTransceiver, m_ptrSelectorThread, m_server);
		//当accept成功后 会调用  ClientHandler 的socketReady
        m_ptrSelectorThread->_register(ptrTransceiver->fd(), ptrCallback, commonnet::NeedRead, 100);
        return commonnet::NeedRead;
}


commonutil::MWThreadServer::ClientHandler::ClientHandler(const commonnet::TransceiverPtr &ptrTransceiver, 
		const commonnet::SelectorThreadPtr &ptrSelectorThread,
		commonutil::MWThreadServer *server)
        :m_ptrTransceiver(ptrTransceiver),
        m_ptrSelectorThread(ptrSelectorThread),
        m_server(server)
{

}
commonutil::MWThreadServer::ClientHandler::~ClientHandler()
{
        m_ptrTransceiver->close();
}

commonnet::SocketStatus commonutil::MWThreadServer::ClientHandler::socketReady()
{
        commonnet::BasicStreamPtr ptrBasicStream;
        try {
				//直接socket读取出来数据
                m_ptrTransceiver->read(ptrBasicStream, false);

                ptrBasicStream->i = ptrBasicStream->b.begin();
                m_server->PushPackage(m_ptrTransceiver, ptrBasicStream);

                return commonnet::NeedRead;
        } catch (...) {
				//读取信息失败的话，直接把这个socket丢弃
                m_ptrSelectorThread->unregister(this);
                return commonnet::Finished;
        }
}

1.4 工作线程消费信息

commonutil::MWThreadServer::WorkerThread::WorkerThread(int nIndex, MWThreadServer* server, Handler *handler)
        : commonutil::Thread("WorkerThread"),
        m_bContinue(true),
        m_nIndex(nIndex),
        m_server(server),
        m_handler(handler)
{
}

commonutil::MWThreadServer::WorkerThread::~WorkerThread()
{
}
//消费消息
void commonutil::MWThreadServer::WorkerThread::run()
{
        commonnet::TransceiverPtr ptrTransceiver;
        commonnet::BasicStreamPtr ptrBasicStream;
        while (m_bContinue) {
                if (!m_server->PopPackage(ptrTransceiver, ptrBasicStream)) {
                        break;
                }
                m_handler->handleRequest(ptrTransceiver, ptrBasicStream);
        }
}

2.关闭程序

信号产生方式对进程的影响

sighup 内核驱动发现终端（或伪终端）关闭 给终端对应的控制进程（bash）发 SIGHUP bash 收到 SIGHUP 后，会给各个作业（包括前后台）发送 SIGHUP，然后自己退出 前后台的各个作业收到来自 bash 的 SIGHUP 后退出（如果程序会处理 SIGHUP，就不会退出）
sigint 通过ctrl+c将会对当进程发送此信号 信号被当前进程树接收到，也就是说，不仅当前进程会收到信号，它的子进程也会收到
sigterm kill命令不加参数就是发送这个信号 只有当前进程收到信号，子进程不会收到。如果当前进程被kill了，那么它的子进程的父进程将会是init，也就是pid为1的进程

2.1 新建线程检测是否有直到获取到ctrl+c 或者kill信号

commonutil::CtrlCHandlerCallback callback = _handler->getCallback();

int main(){
	commonutil::CtrlCHandler ctrlCHandler;
	
	---{
		commonutil::CtrlCHandler::CtrlCHandler(commonutil::CtrlCHandlerCallback callback)
		{
			StaticMutex::Lock lock(globalMutex);
			if (_handler != 0) {
				throw CtrlCHandlerException(__FILE__, __LINE__);
			} else {
				_callback = callback;
				_handler = this;
				lock.release();
				
				// We block these CTRL+C like signals in the main thread,
				// and by default all other threads will inherit this signal
				// mask.
				
				sigset_t ctrlCLikeSignals;
				sigemptyset(&ctrlCLikeSignals);
				sigaddset(&ctrlCLikeSignals, SIGHUP);
				sigaddset(&ctrlCLikeSignals, SIGINT);
				sigaddset(&ctrlCLikeSignals, SIGTERM);
				int rc = pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, 0);
				assert(rc == 0);

				// Joinable thread
				rc = pthread_create(&_tid, 0, sigwaitThread, 0);
				
				assert(rc == 0);
			}
		}
		
	}---
	
	ctrlCHandler.setCallback(InterruptedCallback);
}

2.2 监听命令,停止任务

static void* sigwaitThread(void*)
{
	sigset_t ctrlCLikeSignals;
	sigemptyset(&ctrlCLikeSignals);
	sigaddset(&ctrlCLikeSignals, SIGHUP); 
	sigaddset(&ctrlCLikeSignals, SIGINT);
	sigaddset(&ctrlCLikeSignals, SIGTERM);

	for (;;) {
		int signal = 0;
		int rc = sigwait(&ctrlCLikeSignals, &signal);

		//
		// Some sigwait() implementations incorrectly return EINTR
		// when interrupted by an unblocked caught signal
		//
		if (rc == EINTR) {   //这里注意下
			continue;
		}
		assert(rc == 0);
		
		rc = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
		assert(rc == 0);
		
		//这里会调用停止处理任务
		commonutil::CtrlCHandlerCallback callback = _handler->getCallback();
		
		if (callback != 0) {
			callback(signal);
		}

		rc = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
		assert(rc == 0);
	}
	return 0;
}

				

static void InterruptedCallback(int signal)
{
    g_App.ptrServer->stopWork();
	
	---{  
		//停止工作线程
		void commonutil::MWThreadServer::stopWork()
		{
				m_bContinue = false; // 
				m_ptrListenAcceptor->close();
				for (int i = 0; i < m_nThreads; ++i) {
						m_vecWorkerThreadPtr[i]->Stop();
						
						---
							inline void Stop() {
									m_bContinue = false;
							}
						---
						
				}
				for (int i = 0; i < m_nThreads; ++i) {
						commonutil::Monitor<commonutil::Mutex>::Lock autolock(m_monDataItem);
						m_monDataItem.notify();
				}
		}
		
	}---
}  
  

2.3 停止接收客户端的连接

//前面我们看了怎么停止 处理 任务 , 主任务也不接受 客户端发过来的数据了
//还要把获取连接的线程暂停掉 ptrSelectorThread
int main(int argc, char* argv[])
{
	commonutil::CtrlCHandler ctrlCHandler;
	ctrlCHandler.setCallback(InterruptedCallback); //设置了回调函数，等到信号发生  会回调 InterruptedCallback 函数
	

	g_App.ptrTimer = new commonutil::Timer();
	g_App.ptrSelectorThread = new commonnet::SelectorThread(g_App.ptrTimer);
	
	//  ptrSelectorThread 主线程
	---{
		
	
	}---

	RequestHandler requestHandler;
	g_App.ptrServer = new commonutil::MWThreadServer(ptrProperties->getProperty("Local.AllIP"),
										ptrProperties->getPropertyAsInt("T0Service.Port"),
										10,
										g_App.ptrSelectorThread,
										&requestHandler);
	g_App.ptrServer->startWork();
	g_App.ptrServer->join();  //直到获取到ctrl+c 或者kill信号，会不再获取新的连接请求 。
	//stopwork 后 join 退出
	g_App.ptrSelectorThread->destroy();
	
	---{
			void commonnet::SelectorThread::destroy()
			{
				Lock sync(*this);
				assert(!_destroyed);
				_destroyed = true;
				_selector.setInterrupt();
			}
	}---
	
	
	g_App.ptrTimer->destroy();
	g_App.ptrSelectorThread->joinWithThread();   //等到主线程结束任务
	
	---{
		
		void commonnet::SelectorThread::joinWithThread()
		{
			assert(_destroyed);
			if (_thread)
			{
				_thread->getThreadControl().join();
				
				---{
						commonutil::ThreadControl commonutil::Thread::getThreadControl() const
						{
							commonutil::Mutex::Lock lock(_stateMutex);
							if (!_started) {
								throw ThreadNotStartedException(__FILE__, __LINE__);
							}
							return ThreadControl(_thread);
						}
				}---
	
				
			}
		}

	}---
	
}

void commonutil::MWThreadServer::stopWork()
{
        m_bContinue = false;
		m_ptrListenAcceptor->close();
        for (int i = 0; i < m_nThreads; ++i) {
				//	不接受客户端发来的数据
                m_vecWorkerThreadPtr[i]->Stop();
        }
        for (int i = 0; i < m_nThreads; ++i) {
                commonutil::Monitor<commonutil::Mutex>::Lock autolock(m_monDataItem);
                m_monDataItem.notify();
        }
}

//处理用户连接的任务也暂停
// isInterrupted()：测试线程 Thread 对象 是否已经是中断状态，但不清除状态标志
void commonnet::SelectorThread::run()
{
	while (true)
	{
		try
		{
			_selector.select();
		}
		catch(...)
		{
			//commonutil::Error out;
			//out << "exception in selector thread:\n" << ex;
			Lock sync(*this);
			//判断主线程是否结束
			if (_selector.isInterrupted())
			{
				if (_selector.processInterrupt())
				{
					continue;
				}

				//
				// There are two possiblities for an interrupt:
				//
				// 1. The selector thread has been destroyed.
				// 2. A callback is being finished (closed).
				//
				
				//
				// Thread destroyed?
				//
				if (_destroyed)
				{
					break;
				}
			}
			//没事就等待1毫秒
			commonutil::ThreadControl::sleep(commonutil::Time::milliSeconds(1));
			continue;
		}

程序优化(一)

Tue, 17 Jul 2018 00:00:00 +0000

1.c++实现一个不能被继承的类

一般我们都会把构造函数，析构函数设置为private,仿照单例模式来设计。

class class1
{
	public:
		static class1 * getinstance(){
			return new class1();
		}
		static void deleteInstance(class1 *pInstace){
			delete pInstace;
		}
	private:
		class1(){};
		~class1(){};
}

但是在上面模式中，得到的实例都是在堆上，需要我们自己来释放，或者调用对应的函数。

考虑到这一局限，我们可以设计如下的一个类

template <typename T>
class MakeFinal
{
	friend T;
	private:
		MakeFinal(){};
		~MakeFinal(){};
}

class FinalClass2 : virtual public MakeFinal<FinalClass2>
{
	public:
		FinalClass2(){};
		~FinalClass2(){};
}

因为是友元类的关系，FinalClass2 可以调用MakeFinal的构造及析构函数

到那时继承自FinalClass2的类，如果要实例化，因为FinalClass2是虚继承，会跳过FinalClass2,而是直接调用MakeFinal的构造函数.但是此时已经不可以调用MakeFinal的构造函数了。会导致编译错误.

2.如何自定义函数检测内存泄漏

gcc允许为函数设置__attribute__ ((constructor))和__attribute__ ((destructor))两种属性，顾名思义，就是将被修饰的函数作为构造函数或析构函数。程序员可以通过类似下面的方式为函数设置这些属性：

void funcBeforeMain() __attribute__ ((constructor));
void funcAfterMain() __attribute__ ((destructor));

也可以放在函数名之前：

void __attribute__ ((constructor)) funcBeforeMain();
void __attribute__ ((destructor)) funcAfterMain();

带有(constructor)属性的函数将在main()函数之前被执行，而带有(destructor)属性的函数将在main()退出时执行。

leak_detector.h

#ifndef LEAK_DETECTOR_C_H
#define LEAK_DETECTOR_C_H

#pragma (report_mem_leak)

#define FILE_NAME_LENGTH 256  //用于存储malloc被调用的所在的文件名

#define CALL_DEPTH 10 //最大调用深度

#define TIME_LEN 26 //日期字符串的长度

#define OUTPUT_FILE "leak_info.txt" // 存储内存泄漏信息

#define malloc(size) mymalloc(size, __FILE__,__LINE__)

#define calloc(elements, size) mycalloc(elements ,__FILE__,__LINE__)

#define realloc (address, size) myrealloc(address, size, __FILE__,__LINE__)

#define free(mem_ref) myfree(mem_ref)

struct _MEM_TRACE_INFO{
	char ** traceInfo; 
	size_t size;
};

typedef struct  _MEM_TRACE_INFO MEM_TRACE_INFO;

struct _MEM_INFO{
	void *address ;
	unsigned int size ;
	char file_name[FILE_NAME_LENGTH];
	unsigned int line ;
	char allocTime[TIME_LEN];
	MEM_TRACE_INFO * traceInfo;
};

typedef struct _MEM_INFO MEM_INFO;

struct _MEM_LEAK {
	MEM_INFO mem_info;
	struct _MEM_LEAK  *next; 
};

typedef struct  _MEM_LEAK MEM_LEAK;

static void add(MEM_INFO alloc_info);
static void erase(void * address);
static void clear(void);

void *mymalloc(unsigned int, const char* ,unsigned int );
void *mycalloc(unsigned int ,unsigned int , const char* ,unsigned int );
void *myrealloc(void *,unsigned int , const char* ,unsigned int );
void *myfree( void * mem_ref);


static void add_mem_info(void*, unsigned int , const char* ,unsigned int , MEM_TRACE_INFO*);

static void remove_mem_info(void *mem_ref);

void report_mem_lead(void) __attribute__((destructor));

#endif

leak_detector.c

注意一下

#undef malloc
#undef calloc
#undef realloc
#undef free

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <time.h>
#include <execinfo.h>

#undef malloc
#undef calloc
#undef realloc
#undef free

static MEM_LEAK *ptr_start = NULL;
static MEM_LEAK *ptr_end = NULL; 

MEM_TRACE_INFO * getTrackInfo(){
	void * array[CALL_DEPTH];
	size_t size;
	size = backtrace(array,10);
	char ** trace = backtrace_symbols(array,size);
	MEM_TRACE_INFO * traceInfo = (MEM_TRACE_INFO *) malloc( sizeof(MEM_TRACE_INFO ));
	
	if(traceInfo == NULL){
		return NULL;
	}
	traceInfo ->size = size;
	traceInfo ->traceInfo = trace;
	return traceInfo;
}


void add(MEM_INFO alloc_info)
{
	printf("add new allocation info:%d\n", alloc_info.address);
	MEM_LEAK* mem_leak_info =NULL;
	mem_leak_info=(MEM_LEAK*) malloc(sizeof(MEM_LEAK));
	mem_leak_info->mem_info.address = alloc_info.address;
	mem_leak_info->mem_info.size = alloc_info.size;
	strcpy(mem_leak_info->mem_info.file_name,alloc_info.file_name);
	mem_leak_info->mem_info.line=alloc_info.line;
	mem_leak_info->mem_info.traceInfo= alloc_info.traceInfo;
	strncpy(mem_leak_info->mem_info.allocTime,alloc_info.allocTime,TIME_LEN);

	if(ptr_start == NULL){
		ptr_start  = mem_leak_info;
		ptr_end = ptr_start ;
	}else{
		ptr_end->next = mem_leak_info;
		ptr_end = ptr_end->next;
	}
}

void erase(void * address)
{
	MEM_LEAK *temp = ptr_start ;
	MEM_LEAK *pre;

	if(temp != NULL && temp->mem_info.address == address){
		ptr_start = temp->next;
		free(temp->mem_info.traceInfo);
		free(temp);
		return;
	}
	if(temp->next != NULL){
		pre = temp;
		temp = temp->next;
		for(; temp!= NULL; pre= temp,temp=temp->next)
		{
			if(temp->mem_info.address == address)
			{
				pre->next = temp ->next; 
				if(temp->next == NULL)
					ptr_end = pre;
				free(temp->mem_info.traceInfo);
				free(temp);
				break;
			}
		}
	}
}




void clear(){
	MEM_LEAK *temp = ptr_start;
	MEM_LEAK* alloc_info = ptr_start ;
	while(alloc_info != NULL)
	{
		alloc_info = alloc_info->next;
		free(temp->mem_info.traceInfo);
		free(temp);
		temp=alloc_info;
	}
}



void *mymalloc(unsigned int size , const char* file ,unsigned int line)
{
	void *ptr = malloc(size);
	if(ptr != NULL){
		MEM_TRACE_INFO *traceinfo = getTrackInfo();
		add_mem_info(ptr,size,file,line,traceinfo);
	}
	return ptr;
}

void *mycalloc(unsigned int elements ,unsigned int size , const char* file,unsigned int line)
{
	printf("calloc\n");
	unsigned total_size;
	void *ptr = calloc(elements,size);
	if(ptr != NULL)
	{
		MEM_TRACE_INFO* traceinfo = getTrackInfo();
		total_size = elements *size;
		add_mem_info(ptr,total_size,file,line,traceinfo);
	}
}

void *myrealloc(void * address ,unsigned int size , const char* file,unsigned int line)
{
	printf("realloc\n");
	unsigned total_size;
	void *ptr = realloc(address,size);
	if(ptr != NULL)
	{
		MEM_TRACE_INFO* traceinfo = getTrackInfo();
		remove_mem_info(address);
		add_mem_info(address,size,file,line,traceinfo);
	}
}


void *myfree( void * mem_ref)
{
	remove_mem_info(mem_ref);
	free(mem_ref);
}


void add_mem_info(void* mem_ref, unsigned int size, const char*file ,unsigned int line  , MEM_TRACE_INFO* traceinfo) 
{
	MEM_INFO mem_alloc_info;
	memset(&mem_alloc_info ,0 ,sizeof(mem_alloc_info));
	mem_alloc_info.address = mem_ref;
	mem_alloc_info.size = size;
	strcpy(mem_alloc_info.file_name, file);
	mem_alloc_info.line = line ;
	mem_alloc_info.traceInfo = traceinfo;
	time_t timeP = time(0);
	char* t = ctime(&timeP);
	strncpy(mem_alloc_info.allocTime ,t ,TIME_LEN);
	add(mem_alloc_info);
}

void remove_mem_info(void *mem_ref){
	erase(mem_ref);
}

void report_mem_lead(void) {
	unsigned int i ;
	printf("%s","mem_leak");
	unsigned short index ;
	MEM_LEAK * leak_info;

	FILE* fp_write = fopen(OUTPUT_FILE , "w");
	char info[1024];

	if( fp_write != NULL)
	{
		fprintf(fp_write ,"%s\n", "Memory Leak Summary");
		fprintf(fp_write ,"%s\n", "----------------------------------------");
		for( leak_info = ptr_start ; leak_info != NULL; leak_info = leak_info ->next)
		{
			fprintf(fp_write ,"address:%x\n",leak_info->mem_info.address);
			fprintf(fp_write ,"size   :%d bytes\n",leak_info->mem_info.size);
			fprintf(fp_write ,"file   :%s\n",leak_info->mem_info.file_name);
			fprintf(fp_write ,"line   :%d\n",leak_info->mem_info.line);
			fprintf(fp_write ,"Time   :%s\n",leak_info->mem_info.allocTime);
			fprintf(fp_write ,"traceInfo   :\n");
			for(i = 2 ;i < leak_info->mem_info.traceInfo->size-2;i++)
			{
				fprintf(fp_write ,"%s\n",leak_info->mem_info.traceInfo->traceInfo[i]);
			}
			fprintf(fp_write ,"%s\n","----------------------------------------");
		}
	}
	clear();
}

test.c

#include <stdio.h>
#include "leak_detector.h"

int main()
{
	char *p = NULL;
	p = (char*)malloc(4);
	free(p);
	p = (char*)malloc(5);
	p = (char*)malloc(6);
	return 0 ;
}

makefile

test:test.c leak_detector.h leak.so
gcc -o test test.c ./leak.so -rdynamic

leak.so:leak_detector.o
	gcc -shared -o leak.so leak_detector.o  -rdynamic

leak_detector.o:leak_detector.h leak_detector.c
	gcc -fpic -c leak_detector.c -rdynamic

clean:
	rm *.so *.o

检测结果如下:

Memory Leak Summary
----------------------------------------
address:14b6010
size   :5 bytes
file   :test.c
line   :12
Time   :Wed Jul 18 23:31:59 2018

traceInfo   :
./test(main+0x48) [0x400785]
----------------------------------------
address:14b6a60
size   :6 bytes
file   :test.c
line   :14
Time   :Wed Jul 18 23:31:59 2018

traceInfo   :
./test(main+0x60) [0x40079d]
----------------------------------------

linux系统命令

Mon, 16 Jul 2018 00:00:00 +0000

1.iproute2系列命令替代net-tools

netstat -a —> ss 网络连接
netstat -r —> ip route 路由表
netstat -i —> ip -s link 统计接口
netstat -g —> maddr 组播成员
netstat -M —> ss 伪连接

查看当前服务器的网络连接统计

ss -s

查看所有打开的网络端口

ss -l (-pl)列出具体的程序名称

查看所有的socket连接

ss -a 
ss -ta  -t 表示tcp
ss -ua  -u 表示udp
ss -wa  -w 表示raw
ss -xa  -x 表示unix

ifconfig

ip addr show

为网络接口添加一个IP 地址

ip addr add 192.168.1.114/24 dev eth0

查看路由表

ip route show 

ip route add 192.168.0.24/24 via 192.168.0.231

2.tcpdump

tcpdump -i eth0 -nn -X 'port 53' -c 1

-i 用来指定网络接口 
-nn  tcpdump遇到协议号或者端口号，不要将数字转换成协议的名称
-X  需要把协议头和包内容都显示出来
-c   抓取包的数量
port 53 过滤指定端口的包
-e 增加以太网帧头部信息输出
-l  输出变为行缓冲
-t  输出不打印时间戳
-v  输出更加详细的信息
-F  指定过滤表达式所在的文件
-w  将数据保存到文件中

tcpdump -i eth0 -w flowdata

-r  读取raw packets 文件

tcpdump -r flowdata

过滤流量

tcpdump -i eth0 -c 10 'udp' // 其中udp 可以换成 tcp, arp ,rarp ,ip ,ip6, ether

tcpdump -i eth0 -c 3 'dst port 53 or dest port 80'

tcpdump tcp -i eth1 -t -s 0 -c 100 and dst port ! 22 and src net 192.168.1.0/24 -w ./target.cap

(1)tcp: ip icmp arp rarp 和 tcp、udp、icmp这些选项等都要放到第一个参数的位置，用来过滤数据报的类型
(2)-i eth1 : 只抓经过接口eth1的包
(3)-t : 不显示时间戳
(4)-s 0 : 抓取数据包时默认抓取长度为68字节。加上-S 0 后可以抓到完整的数据包
(5)-c 100 : 只抓取100个数据包
(6)dst port ! 22 : 不抓取目标端口是22的数据包
(7)src net 192.168.1.0/24 : 数据包的源网络地址为192.168.1.0/24
(8)-w ./target.cap : 保存成cap文件，方便用ethereal(即wireshark)分析

3.uptime

查看机器的开机时长，还有查看CPU负载情况。

4.free

默认是kb为单位显示，-m 用MB显示，-g 用GB 显示，都向下取整,-b 用byte显示

5.vmstat

vmstat 输出间隔秒数输出次数

vmstat -f // 曾经拥有过的forks

vmstat -d //展示个磁盘的统计信息

6.service

比如这么使用

service sshd stop

service ntpd status

查看有哪些服务可以控制

cd /etc/init.d  

ls -F

service 其实是一个脚本

which service;

/usr/sbin/service

file /usr/sbin/service

/usr/sbin/service: POSIX shell script, ASCII text executable

cat /usr/sbin/service | wc -l

7.linux 运维必备150个命令

线上查询及帮助命令 (2 个)

man   查看命令帮助，命令的词典，更复杂的还有 info，但不常用。
help  查看 Linux 内置命令的帮助，比如 cd 命令。

文件和目录操作命令 (18 个)

ls  全拼 list，功能是列出目录的内容及其内容属性信息。
cd  全拼 change directory，功能是从当前工作目录切换到指定的工作目录。
cp  全拼 copy，其功能为复制文件或目录。
find  查找的意思，用于查找目录及目录下的文件。
mkdir  全拼 make directories，其功能是创建目录。
mv  全拼 move，其功能是移动或重命名文件。
pwd  全拼 print working directory，其功能是显示当前工作目录的绝对路径。
rename  用于重命名文件。
rm  全拼 remove，其功能是删除一个或多个文件或目录。
rmdir  全拼 remove empty directories，功能是删除空目录。
touch  创建新的空文件，改变已有文件的时间戳属性。
tree  功能是以树形结构显示目录下的内容。
basename  显示文件名或目录名。
dirname  显示文件或目录路径。
chattr  改变文件的扩展属性。
lsattr  查看文件扩展属性。
file  显示文件的类型。
md5sum  计算和校验文件的 MD5 值。

查看文件及内容处理命令（21 个）

cat  全拼 concatenate，功能是用于连接多个文件并且打印到屏幕输出或重定向到指定文件中。
tac  tac 是 cat 的反向拼写，因此命令的功能为反向显示文件内容。
more  分页显示文件内容。
less  分页显示文件内容，more 命令的相反用法。
head  显示文件内容的头部。
tail  显示文件内容的尾部。
cut  将文件的每一行按指定分隔符分割并输出。
split  分割文件为不同的小片段。
paste  按行合并文件内容。
sort  对文件的文本内容排序。
uniq  去除重复行
wc  统计文件的行数、单词数或字节数。
iconv  转换文件的编码格式。iconv   -f GBK -t UTF-8  source_file > dest_file
dos2unix  将 DOS 格式文件转换成 UNIX 格式。dos2unix file_name
diff  全拼 difference，比较文件的差异，常用于文本文件。
vimdiff  命令行可视化文件比较工具，常用于文本文件。
rev  反向输出文件内容。
grep/egrep  过滤字符串 grep -r error ./*         -r 递归目录
join  按两个文件的相同字段合并。
tr  替换或删除字符。
vi/vim  命令行文本编辑器。

文件压缩及解压缩命令（4 个）

tar  打包压缩 tar –cvf jpg.tar *.jpg  将目录里所有jpg文件打包成tar.jpg
unzip  解压文件。
gzip  gzip 压缩工具。
zip  压缩工具。

信息显示命令（11 个）

uname  显示操作系统相关信息的命令。
hostname  显示或者设置当前系统的主机名。
dmesg  显示开机信息，用于诊断系统故障。
uptime  显示系统运行时间及负载。
stat  显示文件或文件系统的状态。
du  计算磁盘空间使用情况  du -h 
df  报告文件系统磁盘空间的使用情况。
top  实时显示系统资源使用情况。
free  查看系统内存
date  显示与设置系统时间。
cal  查看日历等时间信息。

搜索文件命令（4 个）

which  查找二进制命令，按环境变量 PATH 路径查找。
find  从磁盘遍历查找文件或目录。
whereis  查找二进制命令，按环境变量 PATH 路径查找。
locate  从数据库 (/var/lib/mlocate/mlocate.db) 查找命令，使用 updatedb 更新库。

用户管理命令（10 个）

useradd  添加用户
usermod  修改系统已经存在的用户属性。
userdel  删除用户。
groupadd  添加用户组。
passwd  修改用户密码。
chage  修改用户密码有效期限。
id  查看用户的 uid,gid 及归属的用户组。
su  切换用户身份。
visudo  编辑 / etc/sudoers 文件的专属命令。
sudo  以另外一个用户身份（默认 root 用户）执行事先在 sudoers 文件允许的命令。

基础网络操作命令（11 个）

telnet  使用 TELNET 协议远程登录
ssh  使用 SSH 加密协议远程登录。
scp  全拼 secure copy，用于不同主机之间复制文件。
wget  命令行下载文件。`
ping  测试主机之间网络的连通性。
route  显示和设置 linux 系统的路由表。
ifconfig  查看、配置、启用或禁用网络接口的命令
ifup  启动网卡。
ifdown  关闭网卡。
netstat  查看网络状态
ss  查看网络状态。

深入网络操作命令（9 个）

nmap  网络扫描命令。
lsof  全名 list open files，也就是列举系统中已经被打开的文件。
mail  发送和接收邮件。
mutt  邮件管理命令。
nslookup  交互式查询互联网 DNS 服务器的命令。
dig  查找 DNS 解析过程。
host  查询 DNS 的命令。
traceroute  追踪数据传输路由状况。
tcpdump  命令行的抓包工具。

有关磁盘与文件系统的命令（16 个）

mount  挂载文件系统。
umount  卸载文件系统。
fsck  检查并修复 Linux 文件系统。
dd  转换或复制文件。
dumpe2fs  导出 ext2/ext3/ext4 文件系统信息。
dump  ext2/3/4 文件系统备份工具。
fdisk  磁盘分区命令，适用于 2TB 以下磁盘分区。
parted  磁盘分区命令，没有磁盘大小限制，常用于 2TB 以下磁盘分区。
mkfs  格式化创建 Linux 文件系统。
partprobe  更新内核的硬盘分区表信息。
e2fsck  检查 ext2/ext3/ext4 类型文件系统。
mkswap  创建 Linux 交换分区。
swapon  启用交换分区。
swapoff  关闭交换分区。
sync  将内存缓冲区内的数据写入磁盘。
resize2fs  调整 ext2/ext3/ext4 文件系统大小。

系统权限及用户授权相关命令（4 个）

chmod  改变文件或目录权限。
chown  改变文件或目录的属主和属组。
chgrp  更改文件用户组。
umask  显示或设置权限掩码。

查看系统用户登陆信息的命令（7 个）

whoami  显示当前有效的用户名称，相当于执行 id -un 命令。
who  显示目前登录系统的用户信息。
w  显示已经登陆系统的用户列表，并显示用户正在执行的指令。
last  显示登入系统的用户。
lastlog  显示系统中所有用户最近一次登录信息。
users  显示当前登录系统的所有用户的用户列表。
finger  查找并显示用户信息。

内置命令及其它（19 个）

echo  打印变量，或直接输出指定的字符串
printf  将结果格式化输出到标准输出。
rpm  管理 rpm 包的命令。
yum  自动化简单化地管理 rpm 包的命令。
watch  周期性的执行给定的命令，并将命令的输出以全屏方式显示。
alias  设置系统别名。`
unalias  取消系统别名。
date  查看或设置系统时间。date -d last-day '+%Y-%m-%d'
clear  清除屏幕，简称清屏。
history  查看命令执行的历史纪录。
eject  弹出光驱。
time  计算命令执行时间。
nc  功能强大的网络工具。
xargs  将标准输入转换成命令行参数。
exec  调用并执行指令的命令。
export  设置或者显示环境变量。
unset  删除变量或函数。
type  用于判断另外一个命令是否是内置命令。
bc  命令行科学计算器

系统管理与性能监视命令 (9 个)

chkconfig  管理 Linux 系统开机启动项。
vmstat  虚拟内存统计。
mpstat  显示各个可用 CPU 的状态统计。
iostat  统计系统 IO。
sar  全面地获取系统的 CPU、运行队列、磁盘 I/O、分页（交换区）、内存、 CPU 中断和网络等性能数据。
ipcs  用于报告 Linux 中进程间通信设施的状态，显示的信息包括消息列表、共享内存和信号量的信息。
ipcrm  用来删除一个或更多的消息队列、信号量集或者共享内存标识。
strace  用于诊断、调试 Linux 用户空间跟踪器。我们用它来监控用户空间进程和内核的交互，比如系统调用、信号传递、进程状态变更等。
ltrace  命令会跟踪进程的库函数调用, 它会显现出哪个库函数被调用。

关机 / 重启 / 注销和查看系统信息的命令（6 个）

shutdown  关机。
halt  关机。
poweroff  关闭电源。
logout  退出当前登录的 Shell。
exit  退出当前登录的 Shell。
Ctrl+d  退出当前登录的 Shell 的快捷键。

进程管理相关命令（15 个）

bg  将一个在后台暂停的命令，变成继续执行  （在后台执行）。
fg  将后台中的命令调至前台继续运行。
jobs  查看当前有多少在后台运行的命令。
kill  终止进程。
killall  通过进程名终止进程。
pkill  通过进程名终止进程。
crontab   定时任务命令。
ps  显示进程的快照。
pstree  树形显示进程。
nice/renice  调整程序运行的优先级。
nohup  忽略挂起信号运行指定的命令。
pgrep  查找匹配条件的进程。
runlevel  查看系统当前运行级别。
init  切换运行级别。
service  启动、停止、重新启动和关闭系统服务，还可以显示所有系统服务的当前状态

Epoll

Wed, 27 Jun 2018 00:00:00 +0000

1.分析

STDIN_FILENO：接收键盘的输入

STDOUT_FILENO：向屏幕输出

epoll步骤

参考：IO多路复用之epoll总结 https://www.cnblogs.com/Anker/p/3263780.html

#include <sys/epoll.h>
int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)
调用epoll_ctl向epoll对象中添加这100万个连接的套接字

EPOLL_CTL_ADD：注册新的fd到epfd中； EPOLL_CTL_MOD：修改已经注册的fd的监听事件； EPOLL_CTL_DEL：从epfd中删除一个fd；
调用epoll_wait收集发生的事件的连接

关于ET、LT两种工作模式

LT：水平触发，效率会低于ET触发，尤其在大并发，大流量的情况下。但是LT对代码编写要求比较低，不容易出现问题。LT模式服务编写上的表现是：只要有数据没有被获取，内核就不断通知你，因此不用担心事件丢失的情况。

ET：边缘触发，效率非常高，在并发，大流量的情况下，会比LT少很多epoll的系统调用，因此效率高。但是对编程要求高，需要细致的处理每个请求，否则容易发生丢失事件的情况。

ev.events = EPOLLIN; //，默认LT模式
ev.events = EPOLLIN | EPOLLET;  表示ET模式

2.服务端代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <sys/types.h>

#define IPADDRESS "127.0.0.1"
#define PORT 6666
#define MAXSIZE 1024
#define LISTENQ 5 
#define FDSIZE 1000
#define EPOLLEVENTS 100

int socket_bind(const char*ip, int port);
void  do_epoll(int listenfd );
void handle_events(int epollfd ,struct epoll_event* events ,int num ,int listenfd ,char*buf);
void handle_accpet(int epolled ,int listenfd);
void do_read(int epolled , int fd ,char* buf);
void do_write(int epolled ,int fd ,char *buf);
void add_event(int epolled ,int fd, int state );
void modify_event(int epolled ,int fd ,int state );
void delete_event(int epolled ,int fd, int state );


int main(int argc , char* argv[])
{
	int listenfd;
	listenfd = socket_bind(IPADDRESS,PORT);
	listen(listenfd, LISTENQ);
	do_epoll(listenfd);
	return 0 ;
}

int socket_bind(const char*ip, int port){
	int listenfd;
	struct sockaddr_in servaddr;
	listenfd = socket(AF_INET, SOCK_STREAM,0);
	if (listenfd == -1 ){
		perror("socket error:");
		exit(1);
	}

	bzero(&servaddr ,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET,ip,&servaddr.sin_addr);
	servaddr.sin_port = htons(port);
	if ( bind (listenfd, (struct sockaddr*)&servaddr ,sizeof(servaddr)) == -1){
		perror("bind error: ");
		exit(1);
	}
	return listenfd;
}

void do_epoll(int listenfd){
	int epollfd;
	struct epoll_event events[EPOLLEVENTS];
	int ret;
	char buf[MAXSIZE];
	memset(buf,0,sizeof(buf));

	epollfd = epoll_create(FDSIZE);

	add_event(epollfd, listenfd, EPOLLIN);

	while(1){
		ret = epoll_wait(epollfd ,events ,EPOLLEVENTS ,-1);
		handle_events(epollfd, events ,ret ,listenfd, buf);
	}
	close(epollfd);
}

void handle_events(int epollfd, struct epoll_event *events ,int nums, int listenfd, char*buf){
	int i , fd ;

	for (i = 0 ; i < nums; i++){
		fd = events[i].data.fd;
		if ((fd == listenfd) && (events[i].events & EPOLLIN))
			handle_accpet(epollfd ,listenfd);
		else if (events[i].events & EPOLLIN )
			do_read(epollfd, fd, buf);
		else if ( events[i].events & EPOLLOUT)
			do_write(epollfd, fd ,buf);
	}
}

void handle_accpet(int epollfd ,int listenfd){
	int clifd ;
	struct sockaddr_in cliaddr;
	socklen_t cliaddrlen;
	clifd = accept(listenfd ,(struct sockaddr*) &cliaddr ,&cliaddrlen);
	if(clifd == -1 )
		perror("accpet error");
	else{
		printf("accept a new client: %s:%d\n ", inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
		add_event(epollfd ,clifd ,EPOLLIN);
	}
}

void do_read(int epollfd ,int fd ,char*buf){
	int nread ;
	nread = read (fd, buf ,MAXSIZE);
	if(nread == -1 ){
		perror("read error:");
		close(fd);
		delete_event(epollfd,fd ,EPOLLIN);
	}else if(nread == 0 ){
		fprintf(stderr ,"client close.\n");
		close(fd);
		delete_event(epollfd, fd, EPOLLIN);
	}else{
		printf("read message is :%s",buf);
		modify_event(epollfd, fd ,EPOLLOUT);
	}
}

void do_write(int epollfd ,int fd ,char*buf){
	int nwrite ;
	nwrite = write(fd, buf ,strlen(buf));
	if (nwrite ==-1 ){
		perror("write error:");
		close (fd);
		delete_event(epollfd , fd ,EPOLLOUT);
	}else{
		modify_event(epollfd ,fd ,EPOLLIN);
	}
	memset(buf, 0 , MAXSIZE);
}

void add_event(int epollfd , int  fd ,int state ){
	struct epoll_event ev ;
	ev.events = state ;
	ev.data.fd = fd ;
	epoll_ctl(epollfd, EPOLL_CTL_ADD ,fd, &ev);
}

void delete_event(int epollfd ,int fd ,int state ){
	struct epoll_event ev;
	ev.events = state ;
	ev.data.fd = fd ;
	epoll_ctl(epollfd ,EPOLL_CTL_DEL,fd,&ev);
}

void modify_event(int epollfd ,int fd ,int state){
	struct epoll_event ev;
	ev.events = state ;
	ev.data.fd = fd ;
	epoll_ctl(epollfd ,EPOLL_CTL_MOD, fd, &ev);
}

3.客户端代码

#include <netinet/in.h>
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <sys/epoll.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>

#define MAXSIZE 1024 
#define IPADDRESS  "127.0.0.1"
#define SERV_PORT 6666
#define FDSIZE 1024
#define EPOLLEVENTS 20

void handle_connection(int sockfd);
void handle_events(int epollfd ,struct epoll_event *events,int num ,int sockfd ,char*buf);
void do_read(int epollfd , int fd ,int sockfd, char* buf);
void do_write(int epollfd ,int fd ,int sockfd ,char* buf);
void add_event(int epollfd ,int fd ,int state );
void delete_event(int epollfd, int fd ,int state );
void modify_event(int epollfd ,int fd ,int state );
int count = 0 ;

int main( int argc ,char* argv[]){
	int sockfd;
	struct sockaddr_in servaddr;
	sockfd = socket(AF_INET , SOCK_STREAM, 0 );
	bzero(&servaddr , sizeof (servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, IPADDRESS , &servaddr.sin_addr);
	if ( 0 !=  connect(sockfd, (struct sockaddr*)&servaddr ,sizeof(servaddr)) ){
		printf("connect %s-%d faild \n", IPADDRESS, SERV_PORT);
		close (sockfd);
		return -1;
	}
	handle_connection(sockfd);
	close(sockfd);
	return 0 ;
}

void handle_connection(int sockfd){
	int epollfd ;
	struct epoll_event events[EPOLLEVENTS];
	char buf[MAXSIZE];
	int ret;
	epollfd = epoll_create(FDSIZE);
	add_event(epollfd ,STDIN_FILENO,EPOLLIN);
	while(1){
		ret = epoll_wait(epollfd, events ,EPOLLEVENTS ,-1);
		handle_events(epollfd ,events ,ret, sockfd ,buf);
	}
	close(epollfd);
}


void handle_events(int epollfd ,struct epoll_event *events ,int num ,int sockfd, char*buf){
	int fd ,i ;
	for( i = 0 ; i < num ;i ++){
		fd = events[i].data.fd;
		if(events[i].events & EPOLLIN)
			do_read(epollfd ,fd ,sockfd ,buf);
		else if( events[i].events & EPOLLOUT)
			do_write(epollfd ,fd ,sockfd ,buf);
	}
}

void do_read(int epollfd ,int fd ,int sockfd ,char*buf){
	int nread ;
	nread = read(fd, buf ,MAXSIZE);
	if(nread == -1 ){
		perror("read error:");
		close(fd);
	}else if(nread == 0 ){
		fprintf(stderr, "server close \n");
		close (fd);
	}else{
		if (fd == STDIN_FILENO) // STDIN_FILENO：接收键盘的输入
			add_event(epollfd ,sockfd ,EPOLLOUT);
		else{ //从服务器读来的数据 删除读，打开写
			delete_event(epollfd, sockfd ,EPOLLIN);
			add_event(epollfd ,STDOUT_FILENO, EPOLLOUT); //往屏幕输出
		}
	}
}


void do_write(int epollfd ,int fd ,int sockfd ,char*buf){
	int nwrite ;
	char temp[100];
	buf[strlen(buf) -1 ] = '\0';
	snprintf(temp, sizeof(temp), "%s_%02d\n",buf ,count++);
	nwrite = write(fd ,temp ,strlen(temp));

	if(nwrite == -1 ){
		perror("write error: ");
		close(fd);
	}else{
		if( fd == STDOUT_FILENO)//STDOUT_FILENO：向屏幕输出
			delete_event(epollfd, fd ,EPOLLOUT);
		else
			modify_event(epollfd ,fd, EPOLLIN);
	}
	memset(buf, 0 ,sizeof(buf));
}

void add_event(int epollfd ,int fd ,int state){
	struct epoll_event ev;
	ev.events = state ;
	ev.data.fd = fd ;
	epoll_ctl(epollfd , EPOLL_CTL_ADD ,fd ,&ev);
}


void delete_event(int epollfd ,int fd ,int state )
{
	struct epoll_event ev ;
	ev.events = state ;
	ev.data.fd  = fd ;
	epoll_ctl(epollfd ,EPOLL_CTL_DEL, fd, &ev);

}

void modify_event(int epollfd ,int fd ,int state ){
	struct epoll_event ev ;
	ev.events = state ;
	ev.data.fd = fd ;
	epoll_ctl(epollfd, EPOLL_CTL_MOD ,fd, &ev);
}

慕课网docker搭建高可用前后端程序命令

Wed, 20 Jun 2018 00:00:00 +0000

Docker虚拟机常用命令

先更新软件包
```
yum -y update
```
安装Docker虚拟机
```
yum install -y docker
```

运行、重启、关闭Docker虚拟机

service docker start
service docker start
service docker stop

搜索镜像
```
docker search 镜像名称
```
下载镜像
```
docker pull 镜像名称
```
查看镜像
```
docker images
```
删除镜像
```
docker rmi 镜像名称
```
运行容器
```
docker run 启动参数  镜像名称
```
查看容器列表
```
docker ps -a
```
停止、挂起、恢复容器

   docker stop 容器ID
   docker pause 容器ID
   docker unpase 容器ID

查看容器信息
```
docker inspect 容器ID
```
删除容器
```
docker rm 容器ID
```

数据卷管理

docker volume create 数据卷名称  #创建数据卷
docker volume rm 数据卷名称  #删除数据卷
docker volume inspect 数据卷名称  #查看数据卷

网络管理

docker network ls 查看网络信息
docker network create --subnet=网段 网络名称
docker network rm 网络名称

避免VM虚拟机挂起恢复之后，Docker虚拟机断网
```
vi /etc/sysctl.conf
```
文件中添加net.ipv4.ip_forward=1这个配置

shell #重启网络服务 systemctl restart network

安装PXC集群，负载均衡，双机热备

安装PXC镜像

docker pull percona/percona-xtradb-cluster

为PXC镜像改名

docker tag percona/percona-xtradb-cluster pxc

创建net1网段

docker network create --subnet=172.18.0.0/16 net1

创建5个数据卷

docker volume create --name v1
docker volume create --name v2
docker volume create --name v3
docker volume create --name v4
docker volume create --name v5

创建备份数据卷（用于热备份数据）
```
docker volume create --name backup
```

创建5节点的PXC集群

注意，每个MySQL容器创建之后，因为要执行PXC的初始化和加入集群等工作，耐心等待1分钟左右再用客户端连接MySQL。另外，必须第1个MySQL节点启动成功，用MySQL客户端能连接上之后，再去创建其他MySQL节点。

#创建第1个MySQL节点
docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=abc123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=abc123456 -v v1:/var/lib/mysql -v backup:/data --privileged --name=node1 --net=net1 --ip 172.18.0.2 pxc
#创建第2个MySQL节点
docker run -d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=abc123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=abc123456 -e CLUSTER_JOIN=node1 -v v2:/var/lib/mysql -v backup:/data --privileged --name=node2 --net=net1 --ip 172.18.0.3 pxc
#创建第3个MySQL节点
docker run -d -p 3308:3306 -e MYSQL_ROOT_PASSWORD=abc123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=abc123456 -e CLUSTER_JOIN=node1 -v v3:/var/lib/mysql --privileged --name=node3 --net=net1 --ip 172.18.0.4 pxc
#创建第4个MySQL节点
docker run -d -p 3309:3306 -e MYSQL_ROOT_PASSWORD=abc123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=abc123456 -e CLUSTER_JOIN=node1 -v v4:/var/lib/mysql --privileged --name=node4 --net=net1 --ip 172.18.0.5 pxc
#创建第5个MySQL节点
docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=abc123456 -e CLUSTER_NAME=PXC -e XTRABACKUP_PASSWORD=abc123456 -e CLUSTER_JOIN=node1 -v v5:/var/lib/mysql -v backup:/data --privileged --name=node5 --net=net1 --ip 172.18.0.6 pxc

安装Haproxy镜像
```
docker pull haproxy
```

宿主机上编写Haproxy配置文件

vi /home/soft/haproxy.cfg

配置文件如下：

global
	#工作目录
	chroot /usr/local/etc/haproxy
	#日志文件，使用rsyslog服务中local5日志设备（/var/log/local5），等级info
	log 127.0.0.1 local5 info
	#守护进程运行
	daemon

defaults
	log	global
	mode	http
	#日志格式
	option	httplog
	#日志中不记录负载均衡的心跳检测记录
	option	dontlognull
    #连接超时（毫秒）
	timeout connect 5000
    #客户端超时（毫秒）
	timeout client  50000
	#服务器超时（毫秒）
    timeout server  50000

#监控界面
listen  admin_stats
	#监控界面的访问的IP和端口
	bind  0.0.0.0:8888
	#访问协议
    mode        http
	#URI相对地址
    stats uri   /dbs
	#统计报告格式
    stats realm     Global\ statistics
	#登陆帐户信息
    stats auth  admin:abc123456
#数据库负载均衡
listen  proxy-mysql
	#访问的IP和端口
	bind  0.0.0.0:3306
    #网络协议
	mode  tcp
	#负载均衡算法（轮询算法）
	#轮询算法：roundrobin
	#权重算法：static-rr
	#最少连接算法：leastconn
	#请求源IP算法：source
    balance  roundrobin
	#日志格式
    option  tcplog
	#在MySQL中创建一个没有权限的haproxy用户，密码为空。Haproxy使用这个账户对MySQL数据库心跳检测
    option  mysql-check user haproxy
    server  MySQL_1 172.18.0.2:3306 check weight 1 maxconn 2000
    server  MySQL_2 172.18.0.3:3306 check weight 1 maxconn 2000
	server  MySQL_3 172.18.0.4:3306 check weight 1 maxconn 2000
	server  MySQL_4 172.18.0.5:3306 check weight 1 maxconn 2000
	server  MySQL_5 172.18.0.6:3306 check weight 1 maxconn 2000
	#使用keepalive检测死链
    option  tcpka

创建两个Haproxy容器

#创建第1个Haproxy负载均衡服务器
docker run -it -d -p 4001:8888 -p 4002:3306 -v /home/soft/haproxy:/usr/local/etc/haproxy --name h1 --privileged --net=net1 --ip 172.18.0.7 haproxy
#进入h1容器，启动Haproxy
docker exec -it h1 bash
haproxy -f /usr/local/etc/haproxy/haproxy.cfg
#创建第2个Haproxy负载均衡服务器
docker run -it -d -p 4003:8888 -p 4004:3306 -v /home/soft/haproxy:/usr/local/etc/haproxy --name h2 --privileged --net=net1 --ip 172.18.0.8 haproxy
#进入h2容器，启动Haproxy
docker exec -it h2 bash
haproxy -f /usr/local/etc/haproxy/haproxy.cfg

Haproxy容器内安装Keepalived，设置虚拟IP

#进入h1容器
docker exec -it h1 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件（参考下方配置文件）
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start
#宿主机执行ping命令
ping 172.18.0.201

配置文件内容如下：

vrrp_instance  VI_1 {
    state  MASTER
    interface  eth0
    virtual_router_id  51
    priority  100
    advert_int  1
    authentication {
        auth_type  PASS
        auth_pass  123456
    }
    virtual_ipaddress {
        172.18.0.201
    }
}

#进入h2容器
docker exec -it h2 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start
#宿主机执行ping命令
ping 172.18.0.201

配置文件内容如下：

vrrp_instance  VI_1 {
    state  MASTER
    interface  eth0
    virtual_router_id  51
    priority  100
    advert_int  1
    authentication {
        auth_type  PASS
        auth_pass  123456
    }
    virtual_ipaddress {
        172.18.0.201
    }
}

宿主机安装Keepalived，实现双主热备

#宿主机执行安装Keepalived
yum -y install keepalived
#修改Keepalived配置文件
vi /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start

Keepalived配置文件如下：

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
       	192.168.99.150
    }
}

virtual_server 192.168.99.150 8888 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP

    real_server 172.18.0.201 8888 {
        weight 1
    }
}

virtual_server 192.168.99.150 3306 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP

    real_server 172.18.0.201 3306 {
        weight 1
    }
}

热备份数据

#进入node1容器
docker exec -it node1 bash
#更新软件包
apt-get update
#安装热备工具
apt-get install percona-xtrabackup-24
#全量热备
innobackupex --user=root --password=abc123456 /data/backup/full

冷还原数据停止其余4个节点，并删除节点

docker stop node2
docker stop node3
docker stop node4
docker stop node5
docker rm node2
docker rm node3
docker rm node4
docker rm node5

node1容器中删除MySQL的数据

#删除数据
rm -rf /var/lib/mysql/*
#清空事务
innobackupex --user=root --password=abc123456 --apply-back /data/backup/full/2018-04-15_05-09-07/
#还原数据
innobackupex --user=root --password=abc123456 --copy-back  /data/backup/full/2018-04-15_05-09-07/

重新创建其余4个节点，组件PXC集群

安装Redis，配置RedisCluster集群

安装Redis镜像
```
docker pull yyyyttttwwww/redis
```

创建net2网段

docker network create --subnet=172.19.0.0/16 net2

创建6节点Redis容器

docker run -it -d --name r1 -p 5001:6379 --net=net2 --ip 172.19.0.2 redis bash
docker run -it -d --name r2 -p 5002:6379 --net=net2 --ip 172.19.0.3 redis bash
docker run -it -d --name r3 -p 5003:6379 --net=net2 --ip 172.19.0.4 redis bash
docker run -it -d --name r4 -p 5004:6379 --net=net2 --ip 172.19.0.5 redis bash
docker run -it -d --name r5 -p 5005:6379 --net=net2 --ip 172.19.0.6 redis bash

启动6节点Redis服务器

#进入r1节点
docker exec -it r1 bash
cp /home/redis/redis.conf /usr/redis/redis.conf
cd /usr/redis/src
./redis-server ../redis.conf
#进入r2节点
docker exec -it r2 bash
cp /home/redis/redis.conf /usr/redis/redis.conf
cd /usr/redis/src
./redis-server ../redis.conf
#进入r3节点
docker exec -it r3 bash
cp /home/redis/redis.conf /usr/redis/redis.conf
cd /usr/redis/src
./redis-server ../redis.conf
#进入r4节点
docker exec -it r4 bash
cp /home/redis/redis.conf /usr/redis/redis.conf
cd /usr/redis/src
./redis-server ../redis.conf
#进入r5节点
docker exec -it r5 bash
cp /home/redis/redis.conf /usr/redis/redis.conf
cd /usr/redis/src
./redis-server ../redis.conf
#进入r6节点
docker exec -it r6 bash
cp /home/redis/redis.conf /usr/redis/redis.conf
cd /usr/redis/src
./redis-server ../redis.conf

创建Cluster集群

#在r1节点上执行下面的指令
cd /usr/redis/src
mkdir -p ../cluster
cp redis-trib.rb ../cluster/
cd ../cluster
#创建Cluster集群
./redis-trib.rb create --replicas 1 172.19.0.2:6379 172.19.0.3:6379 172.19.0.4:6379 172.19.0.5:6379 172.19.0.6:6379 172.19.0.7:6379

打包部署后端项目

进入人人开源后端项目，执行打包（修改配置文件，更改端口，打包三次生成三个JAR文件）
```
mvn clean install -Dmaven.test.skip=true
```
安装Java镜像
```
docker pull java
```

创建3节点Java容器

#创建数据卷，上传JAR文件
docker volume create j1
#启动容器
docker run -it -d --name j1 -v j1:/home/soft --net=host java
#进入j1容器
docker exec -it j1 bash
#启动Java项目
nohup java -jar /home/soft/renren-fast.jar

#创建数据卷，上传JAR文件
docker volume create j2
#启动容器
docker run -it -d --name j2 -v j2:/home/soft --net=host java
#进入j1容器
docker exec -it j2 bash
#启动Java项目
nohup java -jar /home/soft/renren-fast.jar

#创建数据卷，上传JAR文件
docker volume create j3
#启动容器
docker run -it -d --name j3 -v j3:/home/soft --net=host java
#进入j1容器
docker exec -it j3 bash
#启动Java项目
nohup java -jar /home/soft/renren-fast.jar

安装Nginx镜像
```
docker pull nginx
```

创建Nginx容器，配置负载均衡

宿主机上/home/n1/nginx.conf配置文件内容如下：

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	upstream tomcat {
		server 192.168.99.104:6001;
		server 192.168.99.104:6002;
		server 192.168.99.104:6003;
	}
	server {
        listen       6101;
        server_name  192.168.99.104;
        location / {
            proxy_pass   http://tomcat;
            index  index.html index.htm;
        }
    }
}

创建第1个Nginx节点

docker run -it -d --name n1 -v /home/n1/nginx.conf:/etc/nginx/nginx.conf --net=host --privileged nginx

宿主机上/home/n2/nginx.conf配置文件内容如下：

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	upstream tomcat {
		server 192.168.99.104:6001;
		server 192.168.99.104:6002;
		server 192.168.99.104:6003;
	}
	server {
        listen       6102;
        server_name  192.168.99.104;
        location / {
            proxy_pass   http://tomcat;
            index  index.html index.htm;
        }
    }
}

创建第2个Nginx节点

docker run -it -d --name n2 -v /home/n2/nginx.conf:/etc/nginx/nginx.conf --net=host --privileged nginx

在Nginx容器安装Keepalived

#进入n1节点
docker exec -it n1 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件(如下)
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 123456
    }
    virtual_ipaddress {
        192.168.99.151
    }
}
virtual_server 192.168.99.151 6201 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.99.104 6101 {
        weight 1
    }
}

#进入n1节点
docker exec -it n2 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件(如下)
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 123456
    }
    virtual_ipaddress {
        192.168.99.151
    }
}
virtual_server 192.168.99.151 6201 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.99.104 6102 {
        weight 1
    }
}

打包部署前端项目

在前端项目路径下执行打包指令
```
npm run build
```
build目录的文件拷贝到宿主机的/home/fn1/renren-vue、/home/fn2/renren-vue、/home/fn3/renren-vue的目录下面

创建3节点的Nginx，部署前端项目

宿主机/home/fn1/nginx.conf的配置文件

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	server {
		listen 6501;
		server_name  192.168.99.104;
		location  /  {
			root  /home/fn1/renren-vue;
			index  index.html;
		}
	}
}

#启动第fn1节点
docker run -it -d --name fn1 -v /home/fn1/nginx.conf:/etc/nginx/nginx.conf -v /home/fn1/renren-vue:/home/fn1/renren-vue --privileged --net=host nginx

宿主机/home/fn2/nginx.conf的配置文件

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	server {
		listen 6502;
		server_name  192.168.99.104;
		location  /  {
			root  /home/fn2/renren-vue;
			index  index.html;
		}
	}
}

#启动第fn2节点
docker run -it -d --name fn2 -v /home/fn2/nginx.conf:/etc/nginx/nginx.conf -v /home/fn2/renren-vue:/home/fn2/renren-vue --privileged --net=host nginx

宿主机/home/fn3/nginx.conf的配置文件

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	server {
		listen 6503;
		server_name  192.168.99.104;
		location  /  {
			root  /home/fn3/renren-vue;
			index  index.html;
		}
	}
}

启动fn3节点

#启动第fn3节点
docker run -it -d --name fn3 -v /home/fn3/nginx.conf:/etc/nginx/nginx.conf -v /home/fn3/renren-vue:/home/fn3/renren-vue --privileged --net=host nginx

配置负载均衡

宿主机/home/ff1/nginx.conf配置文件

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	upstream fn {
		server 192.168.99.104:6501;
		server 192.168.99.104:6502;
		server 192.168.99.104:6503;
	}
	server {
        listen       6601;
        server_name  192.168.99.104;
        location / {
            proxy_pass   http://fn;
            index  index.html index.htm;
        }
    }
}

#启动ff1节点
docker run -it -d --name ff1 -v /home/ff1/nginx.conf:/etc/nginx/nginx.conf --net=host --privileged nginx

宿主机/home/ff2/nginx.conf配置文件

user  nginx;
worker_processes  1;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

	proxy_redirect          off;
	proxy_set_header        Host $host;
	proxy_set_header        X-Real-IP $remote_addr;
	proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
	client_max_body_size    10m;
	client_body_buffer_size   128k;
	proxy_connect_timeout   5s;
	proxy_send_timeout      5s;
	proxy_read_timeout      5s;
	proxy_buffer_size        4k;
	proxy_buffers           4 32k;
	proxy_busy_buffers_size  64k;
	proxy_temp_file_write_size 64k;

	upstream fn {
		server 192.168.99.104:6501;
		server 192.168.99.104:6502;
		server 192.168.99.104:6503;
	}
	server {
        listen       6602;
        server_name  192.168.99.104;
        location / {
            proxy_pass   http://fn;
            index  index.html index.htm;
        }
    }
}

#启动ff2节点
docker run -it -d --name ff2 -v /home/ff2/nginx.conf:/etc/nginx/nginx.conf --net=host --privileged nginx

配置双机热备

#进入ff1节点
docker exec -it ff1 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件(如下)
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 52 //两台机器必须一致
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 123456
    }
    virtual_ipaddress {
        192.168.99.152  //虚拟的IP地址
    }
}
virtual_server 192.168.99.152 6701 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.99.104 6601 {
        weight 1
    }
}

#进入ff1节点
docker exec -it ff2 bash
#更新软件包
apt-get update
#安装VIM
apt-get install vim
#安装Keepalived
apt-get install keepalived
#编辑Keepalived配置文件(如下)
vim /etc/keepalived/keepalived.conf
#启动Keepalived
service keepalived start

vrrp_instance VI_1 {
    state MASTER
    interface ens33
    virtual_router_id 52
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 123456
    }
    virtual_ipaddress {
        192.168.99.152
    }
}
virtual_server 192.168.99.152 6701 {
    delay_loop 3
    lb_algo rr
    lb_kind NAT
    persistence_timeout 50
    protocol TCP
    real_server 192.168.99.104 6602 {
        weight 1
    }
}

C++11

Fri, 27 Apr 2018 00:00:00 +0000

1.匿名函数：lambda表达式

一般的lambda表达式语法是

[捕获列表] (参数列表) -> 返回类型 {函数体}

->返回类型可以省略；如果是无参的，(参数列表)也可以省略，真是各种省。匿名函数是个lambda对象，和函数指针有区别，但一般不用关心它。如果你想把一个匿名函数赋给一个函数指针类似物以待后续使用，可以用auto

auto func = [](int arg) { ... };

2.Strongly-typed enums强类型枚举

传统的C++枚举类型存在一些缺陷：它们会将枚举常量暴露在外层作用域中（这可能导致名字冲突，如果同一个作用域中存在两个不同的枚举类型，但是具有相同的枚举常量就会冲突），而且它们会被隐式转换为整形，无法拥有特定的用户定义类型。在C++11中通过引入了一个称为强类型枚举的新类型，修正了这种情况。强类型枚举由关键字enum class标识。它不会将枚举常量暴露到外层作用域中，也不会隐式转换为整形，并且拥有用户指定的特定类型（传统枚举也增加了这个性质）。

enum class Options {None, One, All};
Options o = Options::All;

3.Override和final

时至今日仍然没有一个强制的机制来标识虚函数会在派生类里被改写。vitual关键字是可选的，这使得阅读代码变得很费劲。因为可能需要追溯到继承体系的源头才能确定某个方法是否是虚函数。为了增加可读性，我总是在派生类里也写上virtual关键字，并且也鼓励大家都这么做。即使这样，仍然会产生一些微妙的错误。看下面这个例子：

class B 
{
public:
   virtual void f(short) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) {std::cout << "D::f" << std::endl;}
};

D::f 按理应当重写 B::f。然而二者的声明是不同的，一个参数是short，另一个是int。因此D::f只是拥有同样名字的另一个函数（重载）而不是重写。当你通过B类型的指针调用f()可能会期望打印出D::f，但实际上则会打出 B::f 。

另一个很微妙的错误情况：参数相同，但是基类的函数是const的，派生类的函数却不是。

class B 
{
public:
   virtual void f(int) const {std::cout << "B::f " << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) {std::cout << "D::f" << std::endl;}
};

同样，这两个函数是重载而不是重写，所以你通过B类型指针调用f()将打印B::f，而不是D::f。

幸运的是，现在有一种方式能描述你的意图。新标准加入了两个新的标识符（不是关键字）:：

override，表示函数应当重写基类中的虚函数。

final，表示派生类不应当重写这个虚函数。

第一个的例子如下：

class B 
{
public:
   virtual void f(short) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) override {std::cout << "D::f" << std::endl;}
};

现在这将触发一个编译错误（后面那个例子，如果也写上override标识，会得到相同的错误提示）：

'D::f' : method with override specifier 'override' did not override any base class methods

另一方面，如果你希望函数不要再被派生类进一步重写，你可以把它标识为final。

可以在基类或任何派生类中使用final。在派生类中，可以同时使用override和final标识。

class B 
{
public:
   virtual void f(int) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) override final {std::cout << "D::f" << std::endl;}
};
 
class F : public D
{
public:
   virtual void f(int) override {std::cout << "F::f" << std::endl;}
};

被标记成final的函数将不能再被F::f重写。

4.Smart Pointers 智能指针

智能指针在C++11版本之后提供，包含在头文件<memory>中，shared_ptr、unique_ptr、weak_ptr

shared_ptr多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。

初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr p4 = new int(1);的写法是错误的

拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象。

get函数获取原始指针

注意不要用一个原始指针初始化多个shared_ptr，否则会造成二次释放同一内存

#include <iostream>
#include <memory>

int main() {
	{   
		int a = 10; 
		std::shared_ptr<int> ptra = std::make_shared<int>(a);
		std::shared_ptr<int> ptra2(ptra); //copy
		std::cout << ptra.use_count() << std::endl;

		int b = 20; 
		int *pb = &a; 
		//std::shared_ptr<int> ptrb = pb;  //error
		std::shared_ptr<int> ptrb = std::make_shared<int>(b);
		ptra2 = ptrb; //assign
		pb = ptrb.get(); //获取原始指针

		std::cout << ptra.use_count() << std::endl;
		std::cout << ptrb.use_count() << std::endl;
		std::cout << *pb << std::endl;                                                                                                                                                                   
	}   
}

unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。

相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。 unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。

unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。

#include <iostream>
#include <memory>

int main() {
	{
		std::unique_ptr<int> uptr(new int(10));  //绑定动态对象
		//std::unique_ptr<int> uptr2 = uptr;  //不能賦值
		//std::unique_ptr<int> uptr2(uptr);  //不能拷貝
		std::unique_ptr<int> uptr2 = std::move(uptr); //轉換所有權
		uptr2.release(); //释放所有权
	}
	//超過uptr的作用域，內存釋放
}

weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->, 它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。

weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。

使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源(也就是shared_ptr的管理的资源)已经不复存在。

weak_ptr可以使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象，从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr。

#include <iostream>
#include <memory>

int main() {
	{
		std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
		std::cout << sh_ptr.use_count() << std::endl;

		std::weak_ptr<int> wp(sh_ptr);
		std::cout << wp.use_count() << std::endl;

		if(!wp.expired()){
			std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
			*sh_ptr = 100;
			std::cout << wp.use_count() << std::endl;
		}
	}
	//delete memory
}	

循环引用

在C++ 里边就要为资源管理费一番脑筋。如果使用原始指针作为成员， Child和Parent由谁释放？那么如何保证指针的有效性？如何防止出现空悬指针？这些问题是C++面向对象编程麻烦的问题，

现在可以借助smart pointer把对象语义（pointer）转变为值（value）语义， shared_ptr轻松解决生命周期的问题，不必担心空悬指针。但是这个模型存在循环引用的问题，注意其中一个指针应该为weak_ptr。

智能指针的设计和实现

下面是一个简单智能指针的demo。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。智能指针就是模拟指针动作的类。

所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。

#include <iostream>
#include <memory>

template<typename T>
class SmartPointer {
private:
	T* _ptr;
	size_t* _count;
public:
	SmartPointer(T* ptr = nullptr) :
			_ptr(ptr) {
		if (_ptr) {
			_count = new size_t(1);
		} else {
			_count = new size_t(0);
		}
	}

	SmartPointer(const SmartPointer& ptr) {
		if (this != &ptr) {
			this->_ptr = ptr._ptr;
			this->_count = ptr._count;
			(*this->_count)++;
		}
	}

	SmartPointer& operator=(const SmartPointer& ptr) {
		if (this->_ptr == ptr._ptr) {
			return *this;
		}

		if (this->_ptr) {
			(*this->_count)--;
			if (this->_count == 0) {
				delete this->_ptr;
				delete this->_count;
			}
		}

		this->_ptr = ptr._ptr;
		this->_count = ptr._count;
		(*this->_count)++;
		return *this;
	}

	T& operator*() {
		assert(this->_ptr == nullptr);
		return *(this->_ptr);

	}

	T* operator->() {
		assert(this->_ptr == nullptr);
		return this->_ptr;
	}

	~SmartPointer() {
		(*this->_count)--;
		if (*this->_count == 0) {
			delete this->_ptr;
			delete this->_count;
		}
	}

	size_t use_count(){
		return *this->_count;
	}
};

int main() {
	{
		SmartPointer<int> sp(new int(10));
		SmartPointer<int> sp2(sp);
		SmartPointer<int> sp3(new int(20));
		sp2 = sp3;
		std::cout << sp.use_count() << std::endl;
		std::cout << sp3.use_count() << std::endl;
	}
	//delete operator
}

C++11中智能指针的原理、使用、实现 https://www.cnblogs.com/wxquare/p/4759020.html

5.std::function

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <functional>
#include <memory>
using namespace std;
 
//声明一个模板
typedef std::function<int(int)> Functional;
 
 
//normal function
int TestFunc(int a)
{
	return a;
}
 
//lambda expression
auto lambda = [](int a)->int{return a;};
 
//functor仿函数
class Functor
{
public:
	int operator() (int a)
	{
		return a;
	}
};
 
 
//类的成员函数和类的静态成员函数
class CTest
{
public:
	int Func(int a)
	{
		return a;
	}
	static int SFunc(int a)
	{
		return a;
	}
};
 
 
int main(int argc, char* argv[])
{
	//封装普通函数
	Functional obj = TestFunc;
	int res = obj(0);
	cout << "normal function : " << res << endl;
 
	//封装lambda表达式
	obj = lambda;
	res = obj(1);
	cout << "lambda expression : " << res << endl;
 
	//封装仿函数
	Functor functorObj;
	obj = functorObj;
	res = obj(2);
	cout << "functor : " << res << endl;
 
	//封装类的成员函数和static成员函数
	CTest t;
	obj = std::bind(&CTest::Func, &t, std::placeholders::_1);
	res = obj(3);
	cout << "member function : " << res << endl;
 
	obj = CTest::SFunc;
	res = obj(4);
	cout << "static member function : " << res << endl;
 
	return 0;
}

6.std::bind

//学习bind的用法
void f(int n1, int n2, int n3, const int & n4, int n5)
{
	std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << "\n";
}

int n = 7;
auto f1 = std::bind(f, std::placeholders::_2, std::placeholders::_1, 43, std::cref(n), n);
//第一位置 目标函数（f）的第一个参数 是调用时传的第二个参数
//第二位置 目标函数（f）的第二个参数 是调用时传的第一个参数
//第三位置 目标函数（f）的第三个参数 是43
//第四位置 目标函数（f）的第四个参数 是n的按址传递
//第五位置 目标函数（f）的第五个参数 是n
n = 10;
f1(1, 2);//相当于f(2,1,43,10,7);

#include <iostream>
#include <functional>   //std::cout
using namespace std;
using namespace std::placeholders;    // adds visibility of _1, _2, _3,...

class Test
{
public:
    int i = 0;

    void func(int x, int y)
    {
        cout << x << " " << y << endl;
    }
};

int main()
{
    Test obj; //创建对象

    function<void(int, int)> f1 = bind(&Test::func, &obj, _1, _2);
    f1(1, 2);   //输出：1 2

    function< int &()> f2 = bind(&Test::i, &obj);
    f2() = 123;
    cout << obj.i << endl;//结果为 123

    return 0;
}

#include <random>
#include <iostream>
#include <memory>
#include <functional>
 
void f(int n1, int n2, int n3, const int& n4, int n5)
{
    std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}
 
int g(int n1)
{
    return n1;
}
 
struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};
 
int main()
{
    using namespace std::placeholders;  // 对于 _1, _2, _3...
 
    // 演示参数重排序和按引用传递
    int n = 7;
    // （ _1 与 _2 来自 std::placeholders ，并表示将来会传递给 f1 的参数）
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 为 _1 所绑定， 2 为 _2 所绑定，不使用 1001
                    // 进行到 f(2, 1, 42, n, 7) 的调用
 
    // 嵌套 bind 子表达式共享占位符
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12); // 进行到 f(12, g(12), 12, 4, 5); 的调用
 
    // 常见使用情况：以分布绑定 RNG
    std::default_random_engine e;
    std::uniform_int_distribution<> d(0, 10);
    std::function<int()> rnd = std::bind(d, e); // e 的一个副本存储于 rnd
    for(int n=0; n<10; ++n)
        std::cout << rnd() << ' ';
    std::cout << '\n';
 
    // 绑定指向成员函数指针
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);
    f3(5);
 
    // 绑定指向数据成员指针
    auto f4 = std::bind(&Foo::data, _1);
    std::cout << f4(foo) << '\n';
 
    // 智能指针亦能用于调用被引用对象的成员
    std::cout << f4(std::make_shared<Foo>(foo)) << '\n'
              << f4(std::make_unique<Foo>(foo)) << '\n';
}

附录

1.C++11初探：lambda表达式和闭包 http://www.cnblogs.com/npbool/p/3434757.html

2.C++11初探：类型推导，auto和decltype http://www.cnblogs.com/npbool/p/3433360.html

数据库原理(锁索引负载均衡集群)

Mon, 16 Apr 2018 00:00:00 +0000

1.锁

1.0 系统设置

select version(); //数据库版本

show variables like '%engine%'; //数据库引擎

select @@global.tx_isolation, @@session.tx_isolation, @@tx_isolation; //事务隔离级别

show variables like 'innodb_locks_unsafe_for_binlog'; //查看gap锁开启状态
//innodb_locks_unsafe_for_binlog：默认值为0，即启用gap lock。
//开启innodb_locks_unsafe_for_binlog的REPEATABLE-READ事务隔离级别，
	很大程度上已经蜕变成了READ-COMMITTED

1.1 乐观锁

对于读操作远多于写操作的时候，大多数都是读取，这时候采用乐观锁

1.1.1 乐观锁实现方式：

版本号（记为version）

	就是给数据增加一个版本标识，在数据库上就是表中增加一个version字段，每次更新把这个字段加1，
	读取数据的时候把version读出来，更新的时候比较version，如果还是开始读取的version就可以更新了，
	如果现在的version比老的version大，说明有其他事务更新了该数据，并增加了版本号，
	这时候得到一个无法更新的通知，
	用户自行根据这个通知来决定怎么处理，比如重新开始一遍。
	这里的关键是判断version和更新两个动作需要作为一个原子单元执行，
	否则在你判断可以更新以后正式更新之前有别的事务修改了version，
	这个时候你再去更新就可能会覆盖前一个事务做的更新，造成第二类丢失更新，
	所以你可以使用update … where … and version=”old version”这样的语句，
	根据返回结果是0还是非0来得到通知，如果是0说明更新没有成功，
	因为version被改了，如果返回非0说明更新成功。
	
时间戳（timestamp）

	和版本号基本一样，只是通过时间戳来判断而已，
	注意时间戳要使用数据库服务器的时间戳不能是业务系统的时间。
	
待更新字段

	和版本号方式相似，只是不增加额外字段，直接使用有效数据字段做版本控制信息，
	因为有时候我们可能无法改变旧系统的数据库表结构。
	假设有个待更新字段叫count,先去读取这个count,
	更新的时候去比较数据库中count的值是不是我期望的值（即开始读的值），
	如果是就把我修改的count的值更新到该字段，否则更新失败。
	java的基本类型的原子类型对象如AtomicInteger就是这种思想。

1.2 悲观锁

1.3 死锁分析

1.4 避免死锁的方法

1.4.1 查看死锁的方法有两种：

　　1.通过show engine innodb status命令可以查看最后一个死锁的情况。

　　2.通过innodb_print_all_deadlocks参数配置可以将所有死锁的信息都打印到MySQL的错误日志中。

1.4.2 减少死锁发生的方法：

　　1.尽可能的保持事务小型化，减少事务执行的时间可以减少发生影响的概率;

　　2.及时执行commit或者rollback，来尽快的释放锁;

　　3.可以选用较低的隔离级别，比如如果要使用select…for update和 select…lock in share mode语句时可以使用读取提交数据隔离级别;

　　4.当要访问多个表数据或者要访问相同表的不同行集合时，尽可能的保证每次访问的顺序是相同的。比如可以将多个语句封装在存储过程中，通过调用同一个存储过程的方法可以减少死锁的发生

2.mysql事务

2.1 事务的4个特性

原子性(Atomic)

	事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。
	通常，与某个事务关联的操作具有共同的目标，并且是相互依赖的。如果系统只执行这些操作的一个子集，
	则可能会破坏事务的总体目标。原子性消除了系统处理操作子集的可能性。
一致性(Consistency)

	事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。
	这种特性称为事务的一致性。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。
隔离性(Isolation)

	由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态，
	到底是另一个事务执行之前的状态还是中间某个状态，相互之间存在什么影响，是可以通过隔离级别的设置来控制的。
持久性(Durability)

	事务结束后，事务处理的结果必须能够得到固化，即写入数据库文件中即使机器宕机数据也不会丢失，
	它对于系统的影响是永久性的。

2.2 事务并发控制

我们从另外一个方向来说说，如果不对事务进行并发控制，我们看看数据库并发操作是会有那些异常情形，有些使我们可以接受的，有些是不能接受的，注意这里的异常就是特定语境下的，并不一定就是错误什么的。假设有一个order表，有个字段叫count，作为计数用，当前值为100

第一类丢失更新（Update Lost）

	此种更新丢失是因为回滚的原因，所以也叫回滚丢失。此时两个事务同时更新count，
	两个事务都读取到100，事务一更新成功并提交，count=100+1=101，事务二出于某种原因更新失败了，
	然后回滚，事务二就把count还原为它一开始读到的100，此时事务一的更新就这样丢失了。
脏读（Dirty Read）

	此种异常时因为一个事务读取了另一个事务修改了但是未提交的数据。举个例子，事务一更新了count=101，
	但是没有提交，事务二此时读取count，值为101而不是100，然后事务一出于某种原因回滚了，
	然后第二个事务读取的这个值就是噩梦的开始。
不可重复读（Not Repeatable Read）

	此种异常是一个事务对同一行数据执行了两次或更多次查询，但是却得到了不同的结果，
	也就是在一个事务里面你不能重复（即多次）读取一行数据，如果你这么做了，
	不能保证每次读取的结果是一样的，有可能一样有可能不一样。造成这个结果是在两次查询之间有别的事务对
	该行数据做了更新操作。举个例子，事务一先查询了count，值为100，此时事务二更新了count=101，
	事务一再次读取count,值就会变成101，两次读取结果不一样。
第二类丢失更新（Second Update Lost）

	此种更新丢失是因为更新被其他事务给覆盖了，也可以叫覆盖丢失。举个例子，两个事务同时更新count，
	都读取100这个初始值，事务一先更新成功并提交，count=100+1=101，事务二后更新成功并提交，
	count=100+1=101,由于事务二count还是从100开始增加，事务一的更新就这样丢失了。
幻读（Phantom Read）

	幻读和不可重复读有点像，只是针对的不是数据的值而是数据的数量。此种异常是一个事务
	在两次查询的过程中数据的数量不同，让人以为发生幻觉，幻读大概就是这么得来的吧。
	举个例子，事务一查询order表有多少条记录，事务二新增了一条记录，
	然后事务一查了一下order表有多少记录，发现和第一次不一样，这就是幻读。

2.3 数据库事务隔离级别

读未提交（Read Uncommitted）
	该隔离级别指即使一个事务的更新语句没有提交,但是别的事务可以读到这个改变，
	几种异常情况都可能出现。极易出错，没有安全性可言，基本不会使用。

读已提交（Read Committed）
	该隔离级别指一个事务只能看到其他事务的已经提交的更新，看不到未提交的更新，
	消除了脏读和第一类丢失更新，这是大多数数据库的默认隔离级别，如Oracle,Sqlserver。

可重复读（Repeatable Read）
	该隔离级别指一个事务中进行两次或多次同样的对于数据内容的查询，得到的结果是一样的，
	但不保证对于数据条数的查询是一样的，只要存在读改行数据就禁止写，
	消除了不可重复读和第二类更新丢失，这是Mysql数据库的默认隔离级别。

串行化（Serializable）
	意思是说这个事务执行的时候不允许别的事务并发执行.完全串行化的读，
	只要存在读就禁止写,但可以同时读，消除了幻读。这是事务隔离的最高级别，
	虽然最安全最省心，但是效率太低，一般不会用。	


级别\异常 第一类更新丢失 脏读 不可重复读 第二类丢失更新 幻读
读未提交 Y Y Y Y Y
读已提交 N N Y Y Y
可重复读 N N N N Y
串行化	 N N N N N

3.索引

创建索引的优势：

提高数据的检索速度，降低数据库IO成本：使用索引的意义就是通过缩小表中需要查询的记录的数目从而加快搜索的速度。
降低数据排序的成本，降低CPU消耗：索引之所以查的快，是因为先将数据排好序，若该字段正好需要排序，则真好降低了排序的成本。

创建索引的劣势：

占用存储空间：索引实际上也是一张表，记录了主键与索引字段，一般以索引文件的形式存储在磁盘上。
降低更新表的速度：表的数据发生了变化，对应的索引也需要一起变更，从而减低的更新速度。否则索引指向的物理数据可能不对，这也是索引失效的原因之一。
优质索引创建难：索引的创建并非一日之功，也并非一直不变。需要频繁根据用户的行为和具体的业务逻辑去创建最佳的索引。

基本语法：

创建：
create [unique] index indexName on tableName (columnName...)
alter tableName add [unique] index [indexName] on (columnName...)

删除：
drop index [indexName] on tableName

查看：
show index from tableName

哪些情况需要建索引：

主键，唯一索引
经常用作查询条件的字段需要创建索引
经常需要排序、分组和统计的字段需要建立索引
查询中与其他表关联的字段，外键关系建立索引

哪些情况不要建索引：

表的记录太少，百万级以下的数据不需要创建索引
经常增删改的表不需要创建索引
数据重复且分布平均的字段不需要创建索引，如 true,false 之类。
频繁更新的字段不适合创建索引
where条件里用不到的字段不需要创建索引

explain 分析sql语句

使用explain关键字可以模拟优化器执行sql查询语句，从而得知MySQL 是如何处理sql语句。

+----+-------------+------------+-------+---------------+--------------+---------+-------+------+-------+
| id | select_type | table      | type  | possible_keys | key          | key_len | ref   | rows | Extra |
+----+-------------+------------+-------+---------------+--------------+---------+-------+------+-------+
|  1 | SIMPLE      | t_t0_order | const | F_trade_id_2  | F_trade_id_2 | 93      | const |    1 |       |
+----+-------------+------------+-------+---------------+--------------+---------+-------+------+-------+

id

select 查询的序列号，包含一组可以重复的数字，表示查询中执行sql语句的顺序。一般有三种情况：
第一种：id全部相同，sql的执行顺序是由上至下；
第二种：id全部不同，sql的执行顺序是根据id大的优先执行；
第三种：id既存在相同，又存在不同的。先根据id大的优先执行，再根据相同id从上至下的执行。

select_type

select 查询的类型，主要是用于区别普通查询，联合查询，嵌套的复杂查询
simple：简单的select 查询，查询中不包含子查询或者union
primary：查询中若包含任何复杂的子查询，最外层查询则被标记为primary
subquery：在select或where 列表中包含了子查询
derived：在from列表中包含的子查询被标记为derived（衍生）MySQL会递归执行这些子查询，把结果放在临时表里。
union：若第二个select出现在union之后，则被标记为union，若union包含在from子句的子查询中，外层select将被标记为：derived
union result：从union表获取结果的select

partitions

表所使用的分区，如果要统计十年公司订单的金额，可以把数据分为十个区，每一年代表一个区。这样可以大大的提高查询效率。

type

这是一个非常重要的参数，连接类型，常见的有：all , index , range , ref , eq_ref , const , system , null 八个级别。
性能从最优到最差的排序：system > const > eq_ref > ref > range > index > all。
对java程序员来说，若保证查询至少达到range级别或者最好能达到ref则算是一个优秀而又负责的程序员。

all：（full table scan）全表扫描无疑是最差，若是百万千万级数据量，全表扫描会非常慢。

index：（full index scan）全索引文件扫描比all好很多，毕竟从索引树中找数据，比从全表中找数据要快。

range：只检索给定范围的行，使用索引来匹配行。范围缩小了，当然比全表扫描和全索引文件扫描要快。
	sql语句中一般会有between，in，>，< 等查询。

ref：非唯一性索引扫描，本质上也是一种索引访问，返回所有匹配某个单独值的行。比如查询公司所有属于研发团队的同事，匹配的结果是多个并非唯一值。

eq_ref：唯一性索引扫描，对于每个索引键，表中有一条记录与之匹配。比如查询公司的CEO，匹配的结果只可能是一条记录，

const：表示通过索引一次就可以找到，const用于比较primary key 或者unique索引。因为只匹配一行数据，所以很快，
	若将主键至于where列表中，MySQL就能将该查询转换为一个常量。

system：表只有一条记录（等于系统表），这是const类型的特列，平时不会出现，了解即可

possible_keys

显示查询语句可能用到的索引(一个或多个或为null)，不一定被查询实际使用。仅供参考使用。

key

显示查询语句实际使用的索引。若为null，则表示没有使用索引。

key_len

显示索引中使用的字节数，可通过key_len计算查询中使用的索引长度。
在不损失精确性的情况下索引长度越短越好。key_len 显示的值为索引字段的最可能长度，
并非实际使用长度，即key_len是根据表定义计算而得，并不是通过表内检索出的。

ref

显示索引的哪一列或常量被用于查找索引列上的值。

rows

根据表统计信息及索引选用情况，大致估算出找到所需的记录所需要读取的行数，值越大越不好。

extra

Using filesort： 说明MySQL会对数据使用一个外部的索引排序，而不是按照表内的索引顺序进行读取。
MySQL中无法利用索引完成的排序操作称为“文件排序” 。出现这个就要立刻优化sql。

Using temporary： 使用了临时表保存中间结果，MySQL在对查询结果排序时使用临时表。
常见于排序 order by 和 分组查询 group by。 出现这个更要立刻优化sql。

Using index： 表示相应的select 操作中使用了覆盖索引（Covering index），
避免访问了表的数据行，效果不错！如果同时出现Using where，表明索引被用来执行索引键值的查找。
如果没有同时出现Using where，表示索引用来读取数据而非执行查找动作。

覆盖索引（Covering Index） ：也叫索引覆盖，就是select 的数据列只用从索引中就能够取得，
不必读取数据行，MySQL可以利用索引返回select 列表中的字段，而不必根据索引再次读取数据文件。

Using index condition： 在5.6版本后加入的新特性，优化器会在索引存在的情况下，
通过符合RANGE范围的条数 和 总数的比例来选择是使用索引还是进行全表遍历。

Using where： 表明使用了where 过滤。

Using join buffer： 表明使用了连接缓存。

impossible where： where 语句的值总是false，不可用，不能用来获取任何元素。

distinct： 优化distinct操作，在找到第一匹配的元组后即停止找同样值的动作。

filtered
一个百分比的值，和rows 列的值一起使用，可以估计出查询执行计划(QEP)中的前一个表的结果集，
从而确定join操作的循环次数。小表驱动大表，减轻连接的次数。

3.高性能高可用

3.1 `MHA`

当master出现故障时，通过对比slave之间I/O thread 读取主库binlog的position号，选取最接近的slave作为被选主库。
缺点：需要开启linux系统的互信协议，对于系统安全有影响。

3.2 `MM + Keepalived`

双主热备(这里2个都要设置backup，互为主备)

Keepalived基于VRRP(virtual redundent routing protocol)协议。

3.3 `haproxy + PXC`

(基于Galera协议的Percona XtraDB Cluster实现真正意义上同步复制)

haproxy: 负载均衡

pxc 最小要3个mysql实例，三个实例之间不是主从模式，各自为主，不分从属。实现高性能

有6个mysql示例是最理想的。其中3主3从，实现真正的高可用

3.4 `基于中间件Proxysql`

读写分离

上诉4种方案，其中1,2方案是比较常用的，不保证数组是一致性(如读数据时还没有从主库更新)，但是针对高价值数据，比如金额，订单信息还是用集群中pxc方案保险一些。

4.附录

数据库事务与锁详解 https://blog.csdn.net/aluomaidi/article/details/52460844?utm_medium=referral
mysql insert锁机制 https://blog.csdn.net/come_on_air/article/details/72783644?locationNum=4&fps=1