linux c++自己使用pthread封装的线程类
#include<iostream>
#include<pthread.h>
#include<unistd.h> using namespace std; //typedef void *(*methodFunction)(void *); class CThread
{
public:
CThread();
~CThread();
void run();
int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
void wait();
private:
void *(*m_WorkFunction)(void *);
void *m_args;
pthread_t m_thread;
int m_count;
int m_state;
}; CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(),
m_count()
{
} CThread::~CThread()
{
m_WorkFunction = NULL;
m_args = NULL;
m_state = ;
} void CThread::run()
{
m_state = pthread_create(&m_thread, NULL, m_WorkFunction,m_args);
} void CThread::wait()
{
if( == m_state)
{
pthread_join(m_thread, NULL);
}
} int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
if(args != NULL)
{
m_args = args;
}
m_WorkFunction = methodFunction; return ;
} void * thread_work(void*)
{
for ( int i = ; i < ; i++)
{
cout << "the thread output the number:"<<i<< endl;
}
} int main(int argc, char * argv[])
{
cout << "test for thread class" <<endl;
CThread T;
T.setWorkMethod(thread_work);
T.run();
T.wait();
cout << "the process ending"<< endl;
return ;
}
//demo2: 传入相应参数
#include<iostream>
#include<pthread.h>
#include<unistd.h> using namespace std; //typedef void *(*methodFunction)(void *); class CThread
{
public:
CThread();
~CThread();
void run();
int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
void wait();
private:
void *(*m_WorkFunction)(void *);
void *m_args;
pthread_t m_thread;
int m_count;
int m_state;
}; CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(),
m_count()
{
} CThread::~CThread()
{
m_WorkFunction = NULL;
m_args = NULL;
m_state = ;
} void CThread::run()
{
m_state = pthread_create(&m_thread, NULL, m_WorkFunction,m_args);
} void CThread::wait()
{
if( == m_state)
{
pthread_join(m_thread, NULL);
}
} int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
if(args != NULL)
{
m_args = args;
}
m_WorkFunction = methodFunction; return ;
} void * thread_work(void* args)
{
for ( int i = ; i < ; i++)
{
cout << "the thread output the number:"<<i<< (char*) args<<endl;
}
} int main(int argc, char * argv[])
{
cout << "test for thread class" <<endl;
CThread T;
T.setWorkMethod(thread_work, (void *)"hellowrold");
T.run();
T.wait();
cout << "the process ending"<< endl;
return ;
}
//demo3:抛出发送信息
#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string> using namespace std;
struct MSG
{
MSG():
_msg_count(),
_msg_str_message("")
{}
int _msg_count;
std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *); class CThread
{
public:
CThread();
~CThread();
void run();
int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
int setSleepTimeForSeconds(int sec);
void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
void stop();
void wait();
private:
static void * func_workFunction(void * args);
void *(*m_WorkFunction)(void *);
void *m_args;
pthread_t m_thread;
int m_count;
int m_state;
bool m_destroy;
int m_sleepSeconds;
MSG m_msg;
}; CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(),
m_count(),
m_sleepSeconds(),
m_destroy(false)
{
m_msg._msg_count = ;
m_msg._msg_str_message ="this is a message";
} CThread::~CThread()
{
m_WorkFunction = NULL;
m_args = NULL;
m_state = ;
} void CThread::run()
{
m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
} void CThread::wait()
{
if( == m_state)
{
pthread_join(m_thread, NULL);
}
}
void * CThread::func_workFunction(void * args)
{
CThread * ptrCThread = (CThread *)args;
while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
{
cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
sleep(ptrCThread->m_sleepSeconds);
}
if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
{
//cout << "DEBUG:run the function "<< endl;
ptrCThread->m_WorkFunction(ptrCThread->m_args);
//cout << "DEBUG:end the function "<< endl;
}
} int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
if(args != NULL)
{
m_args = args;
}
m_WorkFunction = methodFunction;
//cout << "DEBUG:set method "<< endl;
return ;
}
void CThread::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
if(!m_msg._msg_str_message.empty())
{
if(NULL == type)
{
dealMessageFunction(&m_msg);
}else
{ }
}
} int CThread::setSleepTimeForSeconds(int sec)
{
if(sec > )
{
m_sleepSeconds = sec;
}
}
void CThread::stop()
{
m_destroy = true;
} void * thread_work(void* args)
{
for ( int i = ; i < ; i++)
{
cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
}
} void * dealwithMessage(MSG * msg)
{
MSG tmpMsg;
tmpMsg._msg_count = msg->_msg_count;
tmpMsg._msg_str_message = msg->_msg_str_message; cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
} void * tread_work1(void *args)
{
for( int i = ; i< ; i++)
{
cout <<"another tread output: "<< i <<" "<<(char*) args<< std::endl;
}
} int main(int argc, char * argv[])
{
cout << "test for thread class" <<endl;
CThread T;CThread T1;
//T.setWorkMethod(thread_work, (void *)"hellowrold");
T.run();
T1.run();T1.setWorkMethod(tread_work1, (void*)"wssdsfsafa");
T1.sendMessage(dealwithMessage);
sleep();
T.setWorkMethod(thread_work, (void *)"hellowrold");
T.wait();
T1.wait();
cout << "the process ending"<< endl;
return ;
}
//demo4: 线程调用类方法执行
#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string> using namespace std;
struct MSG
{
MSG():
_msg_count(0),
_msg_str_message("")
{}
int _msg_count;
std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);
class CWork
{
public:
CWork();
~CWork();
void init(void *);
};
class CThread
{
public:
CThread();
~CThread();
void run();
int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
int setWorkMethod(CWork & t, void * args = NULL);
// int setWorkMethod(const T *t, void * args = NULL);
int setSleepTimeForSeconds(int sec);
void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
void stop();
void wait();
private:
static void * func_workFunction(void * args);
void *(*m_WorkFunction)(void *);
void *m_args;
pthread_t m_thread;
int m_count;
int m_state;
bool m_destroy;
int m_sleepSeconds;
CWork *ptrCWork;
MSG m_msg;
}; CThread::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(0),
m_count(0),
m_sleepSeconds(2),
m_destroy(false),
ptrCWork(NULL)
{
m_msg._msg_count = 1;
m_msg._msg_str_message ="this is a message";
} CThread::~CThread()
{
m_WorkFunction = NULL;
m_args = NULL;
m_state = 0;
} void CThread::run()
{
m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
} void CThread::wait()
{
if( 0 == m_state)
{
pthread_join(m_thread, NULL);
}
}
void * CThread::func_workFunction(void * args)
{
CThread * ptrCThread = (CThread *)args;
while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy && ptrCThread->ptrCWork == NULL)
{
cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
sleep(ptrCThread->m_sleepSeconds);
}
if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
{
//cout << "DEBUG:run the function "<< endl;
ptrCThread->m_WorkFunction(ptrCThread->m_args);
//cout << "DEBUG:end the function "<< endl;
}else if(NULL !=ptrCThread->ptrCWork && !ptrCThread->m_destroy)
{
ptrCThread->ptrCWork->init(ptrCThread->m_args);
}
} int CThread::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
if(args != NULL)
{
m_args = args;
}
m_WorkFunction = methodFunction;
//cout << "DEBUG:set method "<< endl;
return 0;
}
int CThread::setWorkMethod( CWork & t, void * args)
{
if(args != NULL)
{
m_args = args;
}
ptrCWork = &t;
}
// int CThread::setWorkMethod(const T *t, void * args)
// {
// T * ptrClass = (T*)t;
// ptrClass->init(args);
// }
void CThread::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
if(!m_msg._msg_str_message.empty())
{
if(NULL == type)
{
dealMessageFunction(&m_msg);
}else
{ }
}
} int CThread::setSleepTimeForSeconds(int sec)
{
if(sec > 0)
{
m_sleepSeconds = sec;
}
}
void CThread::stop()
{
m_destroy = true;
} void * thread_work(void* args)
{
for ( int i = 0; i < 20; i++)
{
cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
}
} void * dealwithMessage(MSG * msg)
{
MSG tmpMsg;
tmpMsg._msg_count = msg->_msg_count;
tmpMsg._msg_str_message = msg->_msg_str_message; cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
} void * tread_work1(void *args)
{
for( int i = 0; i< 40; i++)
{
cout <<"another tread output: "<< i <<" "<<(char*) args<< std::endl;
}
} CWork::CWork(){}
CWork::~CWork(){}
void CWork::init(void * args)
{
cout << "this is the class function result: "<< (char*)args <<endl;
} int main(int argc, char * argv[])
{
cout << "test for thread class" <<endl;
CThread T;
CWork work;
//T.setWorkMethod(thread_work, (void *)"hellowrold");
T.run();
sleep(6);
// T.setWorkMethod(thread_work, (void *)"hellowrold");
T.setWorkMethod(work, (void *)"hellowrold");
// T.setWorkMethod(&work, (void *)"hellowrold");
T.wait();
cout << "the process ending"<< endl;
return 0;
}
//demo4:使用类模板方式，线程调用类方法
#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string> using namespace std;
struct MSG
{
MSG():
_msg_count(),
_msg_str_message("")
{}
int _msg_count;
std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);
template<typename T>
class CThread
{
public:
CThread();
~CThread();
void run();
int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
int setWorkMethod(T & t, void * args = NULL);
int setSleepTimeForSeconds(int sec);
void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
void stop();
void wait();
private:
static void * func_workFunction(void * args);
void *(*m_WorkFunction)(void *);
void *m_args;
pthread_t m_thread;
int m_count;
int m_state;
bool m_destroy;
int m_sleepSeconds;
MSG m_msg;
T * m_ptrClass;
}; template<typename T>
CThread<T>::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(),
m_count(),
m_sleepSeconds(),
m_destroy(false),
m_ptrClass(NULL)
{
m_msg._msg_count = ;
m_msg._msg_str_message ="this is a message";
} template<typename T>
CThread<T>::~CThread()
{
m_WorkFunction = NULL;
m_args = NULL;
m_state = ;
} template<typename T>
void CThread<T>::run()
{
m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
} template<typename T>
void CThread<T>::wait()
{
if( == m_state)
{
pthread_join(m_thread, NULL);
}
}
template<typename T>
void * CThread<T>::func_workFunction(void * args)
{
CThread<T> * ptrCThread = (CThread<T> *)args;
while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy && ptrCThread->m_ptrClass == NULL)
{
cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
sleep(ptrCThread->m_sleepSeconds);
}
if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
{
//cout << "DEBUG:run the function "<< endl;
ptrCThread->m_WorkFunction(ptrCThread->m_args);
//cout << "DEBUG:end the function "<< endl;
}else if(NULL !=ptrCThread->m_ptrClass && !ptrCThread->m_destroy)
{
ptrCThread->m_ptrClass->init(ptrCThread->m_args);
}
} template<typename T>
int CThread<T>::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
if(args != NULL)
{
m_args = args;
}
m_WorkFunction = methodFunction;
//cout << "DEBUG:set method "<< endl;
return ;
}
template<typename T>
int CThread<T>::setWorkMethod( T & t, void * args)
{
if(args != NULL)
{
m_args = args;
}
m_ptrClass = &t;
}
template<typename T>
void CThread<T>::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
if(!m_msg._msg_str_message.empty())
{
if(NULL == type)
{
dealMessageFunction(&m_msg);
}else
{ }
}
} template<typename T>
int CThread<T>::setSleepTimeForSeconds(int sec)
{
if(sec > )
{
m_sleepSeconds = sec;
}
} template<typename T>
void CThread<T>::stop()
{
m_destroy = true;
} void * thread_work(void* args)
{
for ( int i = ; i < ; i++)
{
cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
}
} void * dealwithMessage(MSG * msg)
{
MSG tmpMsg;
tmpMsg._msg_count = msg->_msg_count;
tmpMsg._msg_str_message = msg->_msg_str_message; cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
} void * tread_work1(void *args)
{
for( int i = ; i< ; i++)
{
cout <<"another tread output: "<< i <<" "<<(char*) args<< std::endl;
}
} class CWork
{
public:
CWork();
~CWork();
void init(void *);
};
CWork::CWork(){}
CWork::~CWork(){}
void CWork::init(void * args)
{
cout << "this is the class function "<< (char*)args <<endl;
} int main(int argc, char * argv[])
{
cout << "test for thread class" <<endl;
CThread<CWork> T;
CWork work;
//T.setWorkMethod(thread_work, (void *)"hellowrold");
T.run();
sleep();
//T.setWorkMethod(thread_work, (void *)"hellowrold");
T.setWorkMethod(work, (void *)"hellowrold");
// T.setWorkMethod(&work, (void *)"hellowrold");
T.wait();
cout << "the process ending"<< endl;
return ;
}
// worker is changed
#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<string> #define FREE 0
#define BUSY 1
using namespace std;
struct MSG
{
MSG():
_msg_count(),
_msg_str_message("")
{}
int _msg_count;
std::string _msg_str_message;
};
//typedef void *(*methodFunction)(void *);
template<typename T>
class CThread
{
public:
CThread();
~CThread();
void run();
int setWorkMethod(void *(*methodFunction)(void *), void * args = NULL);
int setWorkMethod(T & t, void * args = NULL);
int setSleepTimeForSeconds(int sec);
void sendMessage(void *(*dealMessageFunction)(MSG *), void* type = NULL);
void stop();
void wait();
private:
static void * func_workFunction(void * args);
void *(*m_WorkFunction)(void *);
void *m_args;
pthread_t m_thread;
int m_count;
int m_state;
bool m_destroy;
int m_sleepSeconds;
MSG m_msg;
T * m_ptrClass;
}; template<typename T>
CThread<T>::CThread():
m_WorkFunction(NULL),
m_args(NULL),
m_state(),
m_count(),
m_sleepSeconds(),
m_destroy(false),
m_ptrClass(NULL)
{
m_msg._msg_count = ;
m_msg._msg_str_message ="this is a message";
} template<typename T>
CThread<T>::~CThread()
{
m_WorkFunction = NULL;
m_args = NULL;
m_state = ;
} template<typename T>
void CThread<T>::run()
{
m_state = pthread_create(&m_thread, NULL, func_workFunction, this);
} template<typename T>
void CThread<T>::wait()
{
if( == m_state)
{
pthread_join(m_thread, NULL);
}
}
template<typename T>
void * CThread<T>::func_workFunction(void * args)
{
CThread<T> * ptrCThread = (CThread<T> *)args;
while(NULL == ptrCThread->m_WorkFunction && !ptrCThread->m_destroy && ptrCThread->m_ptrClass == NULL)
{
cout << "the thread do nothing, sleep "<< ptrCThread->m_sleepSeconds<<" seconds" << endl;
sleep(ptrCThread->m_sleepSeconds);
}
if(NULL != ptrCThread->m_WorkFunction && !ptrCThread->m_destroy)
{
//cout << "DEBUG:run the function "<< endl;
ptrCThread->m_WorkFunction(ptrCThread->m_args);
//cout << "DEBUG:end the function "<< endl;
}else if(NULL !=ptrCThread->m_ptrClass && !ptrCThread->m_destroy)
{
ptrCThread->m_ptrClass->init(ptrCThread->m_args);
}
} template<typename T>
int CThread<T>::setWorkMethod(void *(*methodFunction)(void *), void * args)
{
if(args != NULL)
{
m_args = args;
}
m_WorkFunction = methodFunction;
//cout << "DEBUG:set method "<< endl;
return ;
}
template<typename T>
int CThread<T>::setWorkMethod( T & t, void * args)
{
if(args != NULL)
{
m_args = args;
}
m_ptrClass = &t;
}
template<typename T>
void CThread<T>::sendMessage(void *(*dealMessageFunction)(MSG *), void* type)
{
if(!m_msg._msg_str_message.empty())
{
if(NULL == type)
{
dealMessageFunction(&m_msg);
}else
{ }
}
} template<typename T>
int CThread<T>::setSleepTimeForSeconds(int sec)
{
if(sec > )
{
m_sleepSeconds = sec;
}
} template<typename T>
void CThread<T>::stop()
{
m_destroy = true;
} void * thread_work(void* args)
{
for ( int i = ; i < ; i++)
{
cout << "the thread output the number: "<< i <<" "<< (char*) args<<endl;
}
} void * dealwithMessage(MSG * msg)
{
MSG tmpMsg;
tmpMsg._msg_count = msg->_msg_count;
tmpMsg._msg_str_message = msg->_msg_str_message; cout << "[INFO]***get the message from the thread***:"<< tmpMsg._msg_str_message << endl;
} void * tread_work1(void *args)
{
for( int i = ; i< ; i++)
{
cout <<"another tread output: "<< i <<" "<<(char*) args<< std::endl;
}
} class CWork
{
public:
CWork();
~CWork();
void init(void *);
void start(char * args = NULL);
private:
int m_state;
string m_strMsg;
};
CWork::CWork():m_state(FREE){}
CWork::~CWork(){}
void CWork::init(void * args)
{
while(m_state == FREE)
{
cout << "this is the class work function "<< (char*)args <<endl;
sleep();
cout << "wait msg"<<endl;
}
while(m_state == BUSY)
{
cout << "the work start wokrking, the work message is :"<< m_strMsg<<endl;
sleep(); }
/*
for( int i = 0; i < 100 ; i++)
{
cout << "the work start wokrking, the work message is :"<< m_strMsg<<endl;
}
*/ }
void CWork::start(char * args)
{
if( NULL == args)
{
std::cout <<"the start args is none, so nothing to do "<< std::endl;
}else
{
m_strMsg = args;
m_state = BUSY;
}
}
int main(int argc, char * argv[])
{
cout << "test for thread class" <<endl;
CThread<CWork> T;
CWork work;
T.run();
for(int i =;i <; i++)
{
std::cout << "main thread message:first -----" <<i <<std::endl;
} sleep();
cout<<"********set the thread worker"<<endl;
T.setWorkMethod(work, (void *)"hellowrold");
for(int i =;i <; i++)
{
std::cout << "main thread message:second -----" <<i <<std::endl;
}
string strinput;
while(cin>>strinput)
{
cout << strinput << endl;
if(strinput.compare("q") == )
break;
}
cout<<"********set the worker start state"<<endl;
work.start("we have a good way to work");
strinput.clear();
while(cin>>strinput)
{
cout << strinput << endl;
if(strinput.compare("q") == )
break;
}
for(int i =;i <; i++)
{
std::cout << "main thread message:" <<i <<std::endl;
}
// sleep(6);
//T.stop();
T.wait();
cout << "the process ending"<< endl;
return ;
}
linux c++自己使用pthread封装的线程类的更多相关文章
- MFC--串口编程---WIN API的方式将串扣操作封装在线程类中
串口采集数据 本文档介绍的是如何获取串口原始数据并将原始数据解析成可处理或可展示的数据. 一.串口采集有很多方式: 1).MFC有一个专门的控件,直接编程采集,一个控件只能采集一个串口,而且串口名字比 ...
- 转：一个跨WINDOWS LINUX平台的线程类
来源:http://blog.csdn.net/dengxu11/article/details/7232681 继Windows下实现一个CThread封装类之后,这里我再实现一个跨WINDOWS ...
- [转] Linux多线程编程之pthread
转载出处:https://blog.csdn.net/skyroben/article/details/72793409 1.背景知识 Linux没有真正意义上的线程,它的实现是由进程来模拟,所以属于 ...
- Linux系统监控命令及定位Java线程
1.PID.TID的区分 uid是user id,即用户id,root用户的uid是0,0为最高权限,gid是group id,用户组id,使用 id 命令可以很简单的通过用户名查看UID.GID:~ ...
- Linux下的进程类别（内核线程、轻量级进程和用户进程）--Linux进程的管理与调度（四）
本文中出现的,内核线程,轻量级进程,用户进程,用户线程等概念,如果不太熟悉, 可以参见 内核线程.轻量级进程.用户线程三种线程概念解惑(线程≠轻量级进程) Linux进程类别 虽然我们在区分Linux ...
- linux内核——会话、进程组、线程组
会话.进程组.线程组总体关系示意图 待插入 Session(会话)与进程组 Shell 分前后台来控制的不是进程而是作业(Job)或者进程组(Process Group).一个前台作业可以由多个进程组 ...
- Linux 平台如何查看某个进程的线程数?
Linux 平台如何查看某个进程的线程数? 三种方法:1. 使用top命令,具体用法是 top -H 加上这个选项,top的每一行就不是显示一个进程,而是一个线程. 2. 使用ps命令,具体用法是 ...
- Linux有问必答：Linux上如何查看某个进程的线程
原创:LCTT https://linux.cn/article-5633-1.html 译者: GOLinux本文地址:https://linux.cn/article-5633-1.html201 ...
- 【摘】Linux虚拟地址空间布局以及进程栈和线程栈总结
在CSDN上看到的一篇文章,讲的还是满好的. 原文地址:Linux虚拟地址空间布局以及进程栈和线程栈总结 一:Linux虚拟地址空间布局 (转自:Linux虚拟地址空间布局) 在多任务操作系统中,每个 ...
随机推荐
- 【二分答案】【最大流】bzoj3130 [Sdoi2013]费用流
二分最大的边的cap,记作Lim. 把所有的边的cap设为min(Lim,cap[i]). Bob一定会把单位费用加到最大边上. #include<cstdio> #include< ...
- 【最大流】【费用流】bzoj1834 [ZJOI2010]network 网络扩容
引用题解: 最大流+费用流. 第一问最大流即可. 第二问为“最小费用最大流”. 由题意,这一问的可转化为在上一问的“残量网络”上,扩大一些边的容量,使能从新的图中的最大流为k. 那么易得:对于还有剩余 ...
- [POI2014]Hotel
题目大意: 给你一颗$n(n\le5000)$个点的树,选3个点使得它们两两距离相等,问共有几种选法. 思路: 首先我们不难发现一个性质:对于每3个符合条件的点,我们总能找到一个点使得这个点到那3个点 ...
- iOS 调H5方法不执行没反应的坑
调用H5的方法需要给H5传一些参数,参数中包括图片的base64字符串. 错误一: 图片转base64,后面参数不能随便写,正确做法如下 NSData *imageData = UIImageJPEG ...
- 移动端与PHP服务端接口通信流程设计（基础版）
针对 --->非开放性平台 --->公司内部产品 接口特点汇总: 1.因为是非开放性的,所以所有的接口都是封闭的,只对公司内部的产品有效: 2.因为是非开放性的,所以OAuth那套协议是行 ...
- ctags 小记
转:http://www.cnblogs.com/napoleon_liu/archive/2011/01/23/1942738.html 简介 ctags − Generate tag files ...
- 事务的实现就是利用数据库锁（行锁，表锁等），且db上锁，都是在操作之前上锁
悲观锁(Pessimistic Lock), 顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会block直到它拿到锁.传统的关系型数据 ...
- SQLSERVER中汉字提取首字母的拼音函数的实现
--创建一个汉字提取首字母的函数--还存在一点小小的问题(符号?)create function hs(@a varchar(1000)='')returns varchar(1000)asbegin ...
- 关于接口 RandomAccess
今天看到java.util.Collections这个工具类中的 public static <T> void fill(List<? super T> list, T obj ...
- mysql性能检查脚本-部分
#!/bin/sh #ocpyang@126.com export black='\033[0m' export boldblack='\033[1;0m' export red='\033[31m' ...