Lambda expressions, concurrency and static variables

As far as I know, such use of static storage within lambda is legal. Essentially it counts number of entries into the closure:

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>


typedef std::pair<int,int> mypair;

std::ostream &operator<< (std::ostream &os, mypair const &data) {
    return os << "(" << data.first << ": " << data.second << ") ";
}

int main()
{
    int n;
    std::vector<mypair> v;
    std::cin >> n;
    v.reserve(n);

    std::for_each(std::begin(v), std::end(v), [](mypair& x) {
        static int i = 0;
        std::cin >> x.second;
        x.first = i++;
    });

    std::for_each(std::begin(v), std::end(v), [](mypair& x) {
        std::cout << x;
    });

    return 0;
}   

Let assume I have a container 'workers' of threads.

std::vector<std::thread> workers;
for (int i = 0; i < 5; i++) {
    workers.push_back(std::thread([]() 
    {
        std::cout << "thread #" << "start\n";
        doLengthyOperation();
        std::cout << "thread #" << "finish\n";
    }));
}

Provided I join them using for_each and the stored variable in question must count number of active tasks, not just number of entries, what possible implementations for such counter are there, if I want to avoid to rely onto global variables to avoid someone else messing up with it and allowing automatic support for separate "flavors" of threads.

std::for_each(workers.begin(), workers.end(), [](std::thread &t) 
    {
        t.join();
    });