Counting words in files
I see some things that may help you improve your code.

Simplify your code

You don't need a lambda at all.  Use this instead:

    futures.push_back(std::async(wordsInFile,argv[i]));


Also, instead of if (!file.is_open()) use the more idiomatic if (!file).

Fix the counting

If we have two files which both contain the word fox exactly once then I would expect the result of this program to print fox   2 but in fact, it would falsely claim a count of 1.  The problem is this line:

words[j.first] = j.second;


This overwrites the count instead of accumulating it.  This is what you need instead:

words[j.first] += j.second;


Use reserve to prevent reallocations

This code already knows how many futures are going to be created.  The code can be made a little more efficient by using this:

futures.reserve(argc-1);


With large numbers of files, this eliminates the re-allocation that would be required by dynamically resizing the vector.

Check for exceptions

If any of the file names can't be read.  That is, if it can be opened but not read, as with a directory under Linux, this code will throw an error that isn't caught and so therefore results in a crash.  Since future::get() will throw any error that was stored, it's that part of the code that should check for exceptions.  One alternative would be this:

    Words results;
    try {
        results = i.get();
    }
    catch(std::exception &amp;err)
    {
        std::cerr &lt;&lt; "ERROR: " &lt;&lt; err.what() &lt;&lt; '\n';
    }
    catch(std::string &amp;err)
    {
        std::cerr &lt;&lt; "ERROR: " &lt;&lt; err &lt;&lt; '\n';
    }
    for (const auto&amp; j : results) 
    {
        words[j.first] += j.second;
    }


Note that this will simply skip the offending file name but continue to process the rest.

Measure your results

Create a non-parallel version of this code and compare the timing to see if it's faster or slower than this version.  I have found that it's often true that the overhead of the implicit (as in async) or explicit (as in thread) thread creation swamps the savings in time by making things parallel.  The only way to know for sure is to time it.