Multithreaded cURL wrapper
Based on the code you have listed, the answer to both of your questions is: no.

curl_global_init(CURL_GLOBAL_ALL) won't be called only once as you're checking isGlobalInitCalled but not setting it to indicate the initialization shouldn't be done again. curl_global_cleanup() won't be called because you have no matching delete-expression for the destructors to get called (see the memory leaks portion of new expression).

Regarding how to make this work...

For the one-time-initialization, you could eliminate the use of the isGlobalInitCalled variable and just use numberOfCurlProcess instead (in the constructor) like this:

curlWrapper() {
    curlGlobalkey.lock();

    if(numberOfCurlProcess == 0)
    {
        curl_global_init(CURL_GLOBAL_ALL); // this should be called only once in the entire program when a first object using this class.
    }
    numberOfCurlProcess++;

    curlGlobalkey.unlock();

    //globalCurlInit();

    initializeMemoryStruct();
}


For the one-time-cleanup, I'd suggest using smart pointers which "enable automatic, exception-safe, object lifetime management". As to how code using smart pointers could look, that can depend on what the newest version of the C++ standard is that you're able to use. With C++14, I'd use code that instead looked more like:

class Accessor {
public:
    std::unique_ptr&lt;curlWrapper&gt; curl = std::make_unique&lt;curlWrapper&gt;();
};

main() { 
    //somewhere in the main
    std::unique_ptr&lt;Accessor&gt; aa = std::make_unique&lt;Accessor&gt;();
    std::unique_ptr&lt;Accessor&gt; bb = std::make_unique&lt;Accessor&gt;();

    thread(aa).doProcess();
    thread(bb).doProcess();
}


There are other ways to solve the second problem too but if you're going to dynamically allocate instances, smart pointers is the way I'd suggest managing memory as they'll take care of calling the instances' destructors for you.