翻译自codeproject上面的一篇文章,题目是:如何创建一个简单的c++同步锁框架

目录

  1. 介绍

  2. 背景

  3. 临界区 & 互斥 & 信号

    1. 临界区

    2. 互斥

    3. 信号

    4. 更多信息

  4. 建立锁框架的目的

  5. BaseLock类

  6. 临界区类

    1. 构造/拷贝构造

    2. 析构

    3. Lock/TryLock

    4. TryLockFor

    5. 解锁

  7. 信号量类

    1. 构造/拷贝构造

    2. 析构

    3. Lock/TryLock/TryLockFor

    4. 解锁

    5. 释放

  8. 互斥类

    1. 构造/拷贝构造

    2. 析构

    3. Lock/ TryLock/TryLockFor

    4. 解锁

  9. 无锁类

    1. 实现

  10. 自动释放锁类

    1. 实现

  11. 例子

    1. 声明同步对象

    2. 声明带初始计数的信号量对象

    3. 声明跨进程的互斥/信号量对象

    4. 同步示例1 (手动加锁)

    5. 同步示例2 (自动加锁)

    6. 同步示例3 (TryLock/TryLockFor)

  12. 更多的示例

  13. 结论

  14. 参考

1 介绍

  开发多线程/多进程应用时, 同步是一个很大的问题. 你需要让你的程序同时满足单线程和多线程/多进程的应用场合,当然如何管理同步又是另一个话题了。利用锁(同步)机制不会自动帮组你解决上诉问题,但是有助于你找到解决问题的方法。这篇文章向你解释了如何构建简单锁框架,如何在你的应用中运用它。可能很多人已经开发了自己的锁框架,或者利用成熟的库比如boost library或者Intel TBB。但是有时候它们对于你的应用来说可能过于臃肿,也可能并不是你想要的。通过阅读本文,你可能构建符合你自己的锁框架。

本文将解释下面这些东西:

  • BaseLock类

  • Critical Section类

  • Semaphore类

  • Mutex类

  • NoLock类

  • Auto-release Lock

  • 示例

  提示: 本文既不是要讲解高级的锁框架,也不是要讲解同步基元的区别。正如题目所说,本文只会告诉你:如何构建一个简单的锁框架,你可以根据本文的框架结合你自己的需要,运用或者修改它

2 背景

这里你必须了解以下几个同步基元的概念和他们之间的区别:

  • Critical
    Section

  • Semaphore

  • Mutex

如果你对MFC中的同步类(CSingleLock/CMultiLock,
CCriticalSection,
CSemaphore,
and CMutex)有所了解,这将有助于你理解并运用这些类来代替windows函数库去实现一个锁框架。

3 Critical
Section & Mutex & Semaphore

下面这段主要来自于这篇文章 "Synchronization
in Multithreaded Applications with MFC"
,由Arman
S所写,我只是引用其中的内容,所有权为他本人所有。

  • Critical
    Section

临界区工作于用户模式,如果需要可以进入内核模式。如果一个线程运行一段位于临界区的代码,它首先会产生一个自旋区并在一段时间的等待之后进入内核模式并等待临界区对象。实际上临界区由自旋计数和信号量组成。前者用于用户态模式下的等待,后者用于内核模式下的等待(睡眠)。在win32
API中,结构体CRITICAL_SECTION表示了一个临界区。在MFC中,用类CCriticalSection表示。概念上一个临界区表示一段可运行的代码,并保证这段代码在执行过程中不会被中断打断。这样做是为了保证一个单线程在访问共享资源时,拥有绝对占有权。

  • Mutex

互斥与临界区一样,也是用于同步访问时保护共享资源。互斥在内核中实现,因此可以进入内核模式。互斥不仅可以用于线程之间,也可以用于进程之间。一般用于不同进程之间时,它都拥有一个惟一的名字,我们称这种互斥为命名互斥。

  • Semaphore

为了限制访问共享资源的线程数量,我们需要使用信号量。信号量是内核对象,它有一个计数变量用于表示当前正在使用共享资源的线程数。举个例子,下面的代码用MFC的CSemaphore类创建了一个信号量,它能保证在设定的时间周期(这个值有第一个参数设定)内能够同时访问共享资源的最大线程数量,并且初始化完成后的时刻没有线程对资源拥有所有权(有第二个参数设定)。

HANDLE g_sem = CreateSemaphore(NULL,,,NULL);
  • 更多信息

如果想了解更多,请阅读Arms S的这篇文章 here

4 锁框架的目的

  在windows开发中,最常见的同步基元是Critical Section,Semaphore, 和Mutex. 对于初学者他们可能经常使用这些同步基元,却很难去了解同步概念本身。因此建立一个简单的锁框架的出发点是使得不同基元拥有统一的接口和调用方式, 但是按照它们原始的机制去工作,这样更容易理解。

5 BaseLock类

  虽然不同的同步基元作用不一样,但是仍然有一些基本的功能共同点。

  • Lock

  • TryLock

  • TryLockFor (试加锁一段时间)

  • Unlock

  可能有人会想到更多的共同点,但是你可以根据你的需求选择构建你自己的锁框架,这里我只是用这4个函数来简化我们想要说明的问题。我们的 BaseLock类是一个纯虚类,如下所示:

// BaseLock.h

class BaseLock
{
public:
BaseLock();
virtual ~BaseLock();
virtual bool Lock() =;
virtual long TryLock()=;
virtual long TryLockFor(const unsigned int dwMilliSecond)=;
virtual void Unlock()=;
};

注意一点:对于互斥而言,Lock函数返回布尔型,对于其它的基元,这个函数总是返回真。

6 Critical Section类

  因为CRITICAL_SECTION结构体已经存在了,所以这里我们将这个类命名为CriticalSectionEx。这个类继承自BaseLock类,也是CRITICAL_SECTION对象的一个接口类。与BaseLock类相似,我们定义如下:

// CriticalSectionEx.h
#include "BaseLock.h" class CriticalSectionEx :public BaseLock
{
public:
CriticalSectionEx();
CriticalSectionEx(const CriticalSectionEx& b);
virtual ~CriticalSectionEx();
CriticalSectionEx & operator=(const CriticalSectionEx&b)
{
return *this;
}
virtual bool Lock();
virtual long TryLock();
virtual long TryLockFor(const unsigned int dwMilliSecond);
virtual void Unlock();
private:
CRITICAL_SECTION m_criticalSection;
int m_lockCounter;
};
  • 注意, 赋值操作符重载函数"operator="返回自身,是因为我不想让成员对象CRITICAL_SECTION被改变,如果"operator="没有被重载,它会自动调用拷贝函数,这样CRITICAL_SECTION对象的值就会被修改替代。另外为什么没有将赋值操作符函数设为私有?原因在于当一个类比如说A试图从其它类拷贝时,访问私有函数会产生编译错误。

  • 另外,临界区在重入时,如果进入和离开次数不对等将产生未定义行为, 所以我们加入了成员变量m_lockCounter,用来跟踪locks/unlocks的数量。

下面的5个函数是临界区使用时的常用函数:

  • InitializeCriticalSection

  • DeleteCriticalSection

  • EnterCriticalSection

  • LeaveCriticalSection

  • TryEnterCriticalSection

更多信息请参考MSDN。这5个函数将合并如下:

  Constructor/Copy Constructor

// CriticalSectionEx.cpp
CriticalSectionEx::CriticalSectionEx() :BaseLock()
{
InitializeCriticalSection(&m_criticalSection);
m_lockCounter=;
}
CriticalSectionEx::CriticalSectionEx(const CriticalSectionEx& b):BaseLock()
{
InitializeCriticalSection(&m_criticalSection);
m_lockCounter=;
}

  Destructor

// CriticalSectionEx.cpp
CriticalSectionEx::~CriticalSectionEx()
{
assert(m_lockCounter==);
DeleteCriticalSection(&m_criticalSection);
}

  如果CRITICAL_SECTION对象被初始化后,它必须要释放,所以将DeleteCriticalSection放在析构函数里,CriticalSectionEx析构时CRITICAL_SECTION将被自动释放。注意如果m_lockCounter不为0,这意味着加锁和解锁次数不相同,这将导致未定义行为。

  Lock/TryLock

// CriticalSectionEx.cpp
bool CriticalSectionEx::Lock()
{
EnterCriticalSection(&m_criticalSection);
m_lockCounter++
return true;
}
long CriticalSectionEx::TryLock()
{
long ret=TryEnterCriticalSection(&m_criticalSection);
if(ret)
m_lockCounter++;
return ret;
}

这是非常直观的实现方式。不解释了!

  TryLockFor

// CriticalSectionEx.cpp
long CriticalSectionEx::TryLockFor(const unsigned int dwMilliSecond)
{
long ret=;
if(ret=TryEnterCriticalSection(&m_criticalSection))
{
m_lockCounter++;
return ret;
}
else
{
unsigned int startTime,timeUsed;
unsigned int waitTime=dwMilliSecond;
startTime=GetTickCount();
while(WaitForSingleObject(m_criticalSection.LockSemaphore,waitTime)==WAIT_OBJECT_0)
{
if(ret=TryEnterCriticalSection(&m_criticalSection))
{
m_lockCounter++;
return ret;
}
timeUsed=GetTickCount()-startTime;
waitTime=waitTime-timeUsed;
startTime=GetTickCount();
}
return ;
}
}

  注意,原始的TryEnterCriticalSection函数没有时间参数(根据MSDN的说法是为了防止死锁)。因此我用一点技巧来模拟一定时间段内的TryLock机制,使用的时候你需要注意一点,因为微软并没有为CRITICAL_SECTION对象实现这个接口。这里并不保证进入临界区的顺序。

  Unlock

// CriticalSectionEx.cpp
void CriticalSectionEx::Unlock()
{
assert(m_lockCounter>=);
LeaveCriticalSection(&m_criticalSection);
}

  如果获取到CRITICAL_SECTION对象,释放时通过调用"LeaveCriticalSection"来解锁表示离开临界区。主要到m_lockCounter必须大于等于0,否则表示解锁次数大于加锁次数。

7 Semaphore Class

  我们的信号量类也继承自BaseLock类,是Semaphore对象的接口类 (实际上是一个句柄)。如下:

// Semaphore.h
#include "BaseLock.h" class Semaphore :public BaseLock
{
public:
Semaphore(unsigned int count=,const TCHAR *semName=_T(""), LPSECURITY_ATTRIBUTES lpsaAttributes = NULL);
Semaphore(const Semaphore& b);
virtual ~Semaphore();
Semaphore & operator=(const Semaphore&b)
{
return *this;
}
virtual bool Lock();
virtual long TryLock();
virtual long TryLockFor(const unsigned int dwMilliSecond);
virtual void Unlock();
long Release(long count, long * retPreviousCount);
private:
/// Actual Semaphore
HANDLE m_sem;
/// Creation Info
LPSECURITY_ATTRIBUTES m_lpsaAttributes;
/// Semaphore Flag
unsigned int m_count;
};

  注意, 信号量类的构造函数的参数有2个:semName和lpsaAttributes,而BaseLock和 CriticalSectionEx的构造函数没有。另外它的构造函数调用时可以不加参数,因为有默认参数,这几个参数的意义如下:

    • count 信号量的加锁次数

      • 缺省值是1,代表了二值信号量

    • semName 信号量名称

      • 缺省值是NULL

      • 在不同进程间同步时需要设置这个参数 (参考MSDN.)

    • lpsaAttributes 新的信号量的安全属性

      • 缺省值是NULL,代表了缺省的安全属性

      • (想了解更多,参考MSDN.)

下面的函数是信号量的4个常用操作函数:

  • CreateSemaphore

  • CloseHandle

  • WaitForSingleObject

  • ReleaseSemaphore

更多信息可参考MSDN,这4个函数合并如下:

  Constructor/Copy Constructor

// Semaphore.cpp

Semaphore::Semaphore(unsigned int count,const TCHAR *semName, LPSECURITY_ATTRIBUTES lpsaAttributes) :BaseLock()
{
m_lpsaAttributes=lpsaAttributes;
m_count=count;
m_sem=CreateSemaphore(lpsaAttributes,count,count,semName);
}
Semaphore::Semaphore(const Semaphore& b) :BaseLock()
{
m_lpsaAttributes=b.m_lpsaAttributes;
m_count=b.m_count;
m_sem=CreateSemaphore(m_lpsaAttributes,m_count,m_count,NULL);
}

  这里的拷贝构造函数,复制了另一个类的安全属性和计数值,然后创建一个新的信号量对象。

  Destructor

// Semaphore.cpp

Semaphore::~Semaphore()
{
CloseHandle(m_sem);
}

  Lock/TryLock/TryLockFor

// Semaphore.cpp
bool Semaphore::Lock()
{
WaitForSingleObject(m_sem,INIFINITE);
return true;
}
long Semaphore::TryLock()
{
long ret=;
if(WaitForSingleObject(m_sem,) == WAIT_OBJECT_0 )
ret=;
return ret;
}
long Semaphore::TryLockFor(const unsigned int dwMilliSecond)
{
long ret=;
if( WaitForSingleObject(m_sem,dwMilliSecond) == WAIT_OBJECT_0)
ret=;
return ret;
}

  Unlock

// Semaphore.cpp

void Semaphore::Unlock()
{
ReleaseSemaphore(m_sem,,NULL);
}

  Release

  如Ahmed Charfeddine建议的那样,对于信号量的Unlock函数最好可以接受一个表示释放计数的参数并返回成功或失败结果。这是信号量比较特别的地方,你可以重新写一个Release函数进行扩展。

// Semaphore.cpp

void Semaphore::Release(long count, long * retPreviousCount)
{
return ReleaseSemaphore(m_sem,count,retPreviousCount);
}
//用法
BaseLock *lock = new Semaphore();
...
BOOL ret = dynamic_cast<Semaphore*>(lock)->Release();
// OR
Semaphore lock();
...
BOOL ret = lock.Release();

8 Mutex
Class

  互斥类继承自BaseLock,是互斥对象的一个接口类。

// Mutex.h
#include "BaseLock.h" class Mutex :public BaseLock
{
public:
Mutex(const TCHAR *mutexName=NULL, LPSECURITY_ATTRIBUTES lpsaAttributes = NULL);
Mutex(const Mutex& b);
virtual ~Mutex();
Mutex & operator=(const Mutex&b)
{
return *this;
}
virtual bool Lock();
virtual long TryLock();
virtual long TryLockFor(const unsigned int dwMilliSecond);
virtual void Unlock();
bool IsMutexAbandoned()
{
return m_isMutexAbandoned;
)
private:
/// Mutex
HANDLE m_mutex;
/// Creation Security Info
LPSECURITY_ATTRIBUTES m_lpsaAttributes;
/// Flag for whether this mutex is abandoned or not.
bool m_isMutexAbandoned;
};

  注意, 互斥量可以被舍弃,但是我们不想单独为了互斥量改变统一的接口,所以我增加了一个函数IsMutexAbandoned用来检查此互斥量是否在加锁失败时被舍弃了。

互斥量的常用函数如下:

  • CreateMutex

  • CloseHandle

  • WaitForSingleObject

  • ReleaseMutex

更多信息请参考MSDN.

  Constructor/Copy Constructor

// Mutex.cpp
Mutex::Mutex(const TCHAR *mutexName, LPSECURITY_ATTRIBUTES lpsaAttributes) :BaseLock()
{
m_isMutexAbandoned=false;
m_lpsaAttributes=lpsaAttributes;
m_mutex=CreateMutex(lpsaAttributes,FALSE,mutexName);
}
Mutex::Mutex(const Mutex& b)
{
m_isMutexAbandoned=false;
m_lpsaAttributes=b.m_lpsaAttributes;
m_mutex=CreateMutex(m_lpsaAttributes,FALSE,NULL);
}

  Destructor

// Mutex.cpp

Mutex::~Mutex()
{
CloseHandle(m_mutex);
}

  Lock/TryLock/TryLockFor

// Mutex.cpp
void Mutex::Lock()
{
bool returnVal = true;
unsigned long res=WaitForSingleObject(m_mutex,INIFINITE);
if(res=WAIT_ABANDONED)
{
m_isMutexAbandoned=true;
returnVal=false;
}
return returnVal;
}
long Mutex::TryLock()
{
long ret=;
unsigned long mutexStatus= WaitForSingleObject(m_mutex,);
if(mutexStatus== WAIT_OBJECT_0)
ret=;
else if(mutexStatus==WAIT_ABANDONED)
m_isMutexAbandoned=true;
return ret;
}
long Mutex::TryLockFor(const unsigned int dwMilliSecond)
{
long ret=;
unsigned long mutexStatus= WaitForSingleObject(m_mutex,dwMilliSecond);
if(mutexStatus==WAIT_OBJECT_0)
ret=;
else if(mutexStatus==WAIT_ABANDONED)
m_isMutexAbandoned=true;
return ret;
}

  调用Lock函数时,无限等待直到获取互斥对象,当WaitForSingleObject函数返回时便自动获取了互斥对象。调用TryLock时,不等待直接试图获取互斥对象,而TryLockFor会在给定之间内试着获取互斥对象,更多参考信息请看MSDN。注意:对于所有的加锁操作,会判断互斥量是否被舍弃,并重置m_isMutexAbandoned状态。因此加锁失败时,你可以调用IsMutexAbandoned查看是否是因为互斥量被舍弃引起的。

  Unlock

// Mutex.cpp

void Mutex::Unlock()
{
ReleaseMutex(m_mutex);
}

9 NoLock Class

  对于锁框架而言,NoLock类在单线程环境下,只是一个占位符(我的注释:占位符的意思就是不包含具体的操作函数,只是为了保持与其它环境下比如多线程,多进程的使用一致性,可参见后面的示例代码)。我们的Nolock类继承于 BaseLock类,如下:

// NoLock.h
#include "BaseLock.h" class NoLock :public BaseLock
{
public:
NoLock();
NoLock(const NoLock& b);
virtual ~NoLock();
NoLock & operator=(const NoLock&b)
{
return *this;
}
virtual bool Lock();
virtual long TryLock();
virtual long TryLockFor(const unsigned int dwMilliSecond);
virtual void Unlock();
private:
};

  正如上面所说,NoLock类只是一个占位符,所以没有任何成员变量,也没有锁机制函数。

  Implementation

// NoLock.cpp
NoLock::NoLock() :BaseLock()
{
}
NoLock::NoLock(const NoLock& b):BaseLock()
{
}
NoLock::~NoLock()
{
}
bool NoLock::Lock()
{
return true;
}
long NoLock::TryLock()
{
return ;
}
long NoLock::TryLockFor(const unsigned int dwMilliSecond)
{
return ;
}
void NoLock::Unlock()
{
}

NoLock没有做任何事情,只是有返回值时返回真。

10 Auto-release Lock

  当进行同步操作时,匹配加锁和解锁是一件非常恼火的事情,所以创建一个拥有自动释放机制的结构体是非常有必要的。我们可以扩展BaseLock类并按照如下的代码去实现:

// BaseLock.h

Class BaseLock
{
public:
...
class BaseLockObj
{
public:
BaseLockObj(BaseLock *lock);
virtual ~BaseLockObj();
BaseLockObj &operator=(const BaseLockObj & b)
{
return *this;
}
private:
BaseLockObj();
BaseLockObj(const BaseLockObj & b){assert();m_lock=NULL;}
/// The pointer to the lock used.
BaseLock *m_lock;
};
...
};
/// type definition for lock object
typedef BaseLock::BaseLockObj LockObj;

  重载拷贝操作函数,并设为私有,是为了防止从其它对象进行拷贝。缺省的构造函数被设为私有,所以必须通过传递指向BaseLock对象的指针来调用构造函数。

全局声明 BaseLock::BaseLockObj为 LockObj,便于访问。

  Implementation

// BaseLock.cpp 

BaseLock::BaseLockObj::BaseLockObj(BaseLock *lock)
{
assert(lock);
m_lock=lock;
if(m_lock)
m_lock->Lock();
} BaseLock::BaseLockObj::~BaseLockObj()
{
if(m_lock)
{
m_lock->Unlock();
}
} BaseLock::BaseLockObj::BaseLockObj()
{
m_lock=NULL;
}

  如代码所示,当BaseLockObj 被创建时,调用构造函数并执行Lock,自动加锁。

同理,析构时,解锁被调用执行。

这些实现对于所有的同步基元都适用,包括 NoLock,因此它们拥有了统一的接口,并且都继承自BaseLock类。

示例:

...
BaseLock *someLock = new CriticalSectionEx(); // declared in somewhere accessible
...
void SomeThreadFunc()
{
...
if (test==)
{
LockObj lock(someLock);
// Lock is obtained automatically
...
} /// When leaving the if statement lock object is destroyed, so the Lock is automatically released
...
}
...

11 Use-case Examples

  • 声明同步对象
 ...
// MUTEX
BaseLock * pLock = new Mutex ();
// OR
Mutex cLock;
...
// SEMAPHORE
BaseLock * pLock = new Semaphore();
// OR
Semaphore cLock;
...
// CRITICAL SECTION
BaseLock * pLock = new CriticalSectionEx();
// OR
CriticalSectionEx cLock;
...
// NOLOCK
BaseLock *pLock = new NoLock();
// OR
NoLock cLock;
...

  同一应用程序,对于不同的环境比如单线程,多线程,多进程都可以这样声明处理过程:

...

BaseLock *pLock=NULL;
#if SINGLE_THREADED
pLock = new NoLock();
#elif MULTI_THREADED
pLock = new CriticalSectionEx();
#else // MULTI_PROCESS
pLock = new Mutex();
#endif
...
  • 声明信号量对象,附带初始锁计数

...
BaseLock * pLock = new Semaphore();
// OR
Semaphore cLock();
...
  • 声明用于跨进程的互斥量/信号量

...
BaseLock * pLock = new Mutex (_T("MutexName"));
//OR
Mutex cLock(_T("MutexName"));
... // For semaphore, lock count must be input, in order to give semaphore name
BaseLock * pLock = new Semaphore(, _T("SemaphoreName"));
//OR
Semaphore cLock(, _T("SemaphoreName"));
...

对于信号量,此时应该给定初始计数值,然后设定名称。

12 示例1 (手动加锁)

void SomeFunc(SomeClass *sClass)
{
...
pLock->Lock(); //OR cLock.Lock();
...
pLock->Unlock(); //OR cLock.Unlock();
}

13 示例2 (自动加锁)

void SomeFunc()
{
LockObj lock(pLock); //OR LockObj lock(&cLock);
...
} // Lock is auto-released when exiting the function.

或者这样:

void SomeFunc(bool doSomething)
{
...
if(doSomething)
{
LockObj lock(pLock); //OR LockObj lock(&cLock);
...
}// Lock is auto-released when exiting the if-statement.
...
}

14 示例3(TryLock/TryLockFor)

...
if(pLock->TryLock()) //OR cLock.TryLock()
{
// Lock obtained
...
pLock->Unlock(); //OR cLock.Unlock();
}
...
或者:
...
if(pLock->TryLockFor()) //OR cLock.TryLockFor(100) // TryLock for 100 millisecond
{
// Lock obtained
...
pLock->Unlock(); //OR cLock.Unlock();
}

15 更多示例

  更多的例子可以查看 EpServerEngine的源代码。更多的细节可以看这篇文章:

("EpServerEngine - A lightweight Template Server-Client Framework using C++ and Windows Winsock" )

16 Reference

License

This
article, along with any associated source code and files, is
licensed under The
MIT License

********************************************************************************

原文:http://www.codeproject.com/Articles/421976/How-to-create-a-Simple-Lock-Framework-for-Cplusplu

源代码:http://files.cnblogs.com/wb-DarkHorse/SimpleLockFramework.zip

如何创建一个简单的C++同步锁框架(译)的更多相关文章

  1. 如何创建一个简单的Visual Studio Code扩展

    注:本文提到的代码示例下载地址>How to create a simple extension for VS Code VS Code 是微软推出的一款轻量级的代码编辑器,免费,开源,支持多种 ...

  2. 《Entity Framework 6 Recipes》翻译系列 (3) -----第二章 实体数据建模基础之创建一个简单的模型

    第二章 实体数据建模基础 很有可能,你才开始探索实体框架,你可能会问“我们怎么开始?”,如果你真是这样的话,那么本章就是一个很好的开始.如果不是,你已经建模,并在实体分裂和继承方面感觉良好,那么你可以 ...

  3. Windows 8.1 应用再出发 (WinJS) - 创建一个简单项目

    前面几篇我们介绍了如何利用 C# + XAML 完成Windows Store App 功能的实现,接下来的几篇我们来看看如何利用 Html + WinJS 来完成这些功能. 本篇我们使用WinJS ...

  4. ADF_General JSF系列1_创建一个简单的JSF Application

    2015-02-17 Creatd By BaoXinjian

  5. IntelliJ IDEA 15 部署Tomcat及创建一个简单的Web工程

    一.部署Tomcat 二.创建一个简单的Web工程 2.1创建一个新工程 创建一个新工程 设置JDK及选择Web Application (创建的是Web工程) 点击Next,选择工作空间,起个工程名 ...

  6. Symfony2之创建一个简单的web应用

    Symfony2——创建bundle       bundle就像插件或者一个功能齐全的应用,我们在应用层上开发的应用的所有代码,包括:PHP文件.配置文件.图片.css文件.js文件等都会包含在bu ...

  7. 如何创建一个简单的struts2程序

    如何创建一个简单的Struts2程序 “计应134(实验班) 凌豪” 1.创建一个新的Web项目test(File->new->Web Project) 2.Struts2框架的核心配置文 ...

  8. 使用 CodeIgniter 创建一个简单的 Web 站点

    原文:使用 CodeIgniter 创建一个简单的 Web 站点 参考源自: http://www.ibm.com/developerworks/cn/web/wa-codeigniter/index ...

  9. SharePoint 创建一个简单的Web Part 部分

    SharePoint 创建一个简单的Web Part 部分 标准Web零件有时会很强大,运行多个功能的能力. 本文介绍了如何使用Visual Studio 创建一个简单的Web部分. 1. 打开VS, ...

随机推荐

  1. 浏览器控制台console

    console对象 console对象代表浏览器的JavaScript控制台.虽然它还不是标准,但是各大浏览器都原生支持,已经成为事实上的标准. console对象主要有两个作用: 显示网页代码运行时 ...

  2. Linux 计划任务

    实例: 每5分钟定时访问一个url # crontab -e #*/5 * * * * /usr/bin/curl http://aa.com:8080/tools/sitemap.php >& ...

  3. [转] 《ES6标准入门》读书笔记

    来源:https://segmentfault.com/a/1190000005863641 let和const命令 ES6新增let命令,用于声明变量,是块级作用域. let声明的变量不会像var声 ...

  4. iscrolljs 看API 回顾以前开发中失误

    今天有空 细致的看看iscrolljs api 发现自己以前的几个失误是没看api造成的 失误1 页面a操作 影响了页面b的滚动条 api 解释: options.bindToWrapper The ...

  5. A star 寻路

    大白话说一下几个点: 通俗的来说,其实就是以一个规则来 从A点走到B点. 怎么来判断我们走的格子是一个合适的格子? 就是靠一个规则来计算,这个规则就是估价函数. 估价函数: 常用:曼哈顿算法 F = ...

  6. 如何让一个类可以被foreach枚举?

    答:实现IEnumerable或其IEnumerable<T>.该接口只有一个函数 public IEnumerator GetEnumerator(); 在这里,IEnumerator也 ...

  7. ibatis #于 $区别

    系统框架用ibatis,开发中ibatis配置文件中执行order by #orderByClause# ,怎么搞都没有效果, 后面改成 order by $orderByClause$,OK,问题解 ...

  8. Hadoop_UDF示例

    UDF:  一进一出 Eclipse端 1. 继承UDF 2. 实现evaluate方法(可重裁实现多个evaluate方法,以实现不同需求) 3. 导出类jar包,注意指定main方法 Hive端 ...

  9. Linux下配置一个VNC服务器

    在Linux下配置一个VNC服务器,并设置2个用户,要求其中一个用户登录时不需要输入密码. 然后在客户端使用ssh+vncview的方式访问. 1确认vnc安装 2配置vncserver 3测试vnc ...

  10. xdebug所有相关方法函数详解(中文翻译版)

    此次翻译部分借助google翻译,如有错误,请联系qq:903464207反馈问题,或者留言反馈 翻译时间:2016年4月18日09:41:34 xdebug.remote_enable = onxd ...