do mutex's in C++ have to be tied to some object or variable?

Question

I'm somewhat new to threading and I'm trying to understand how it works in C++11. The professor in my class gave us this sample code to demonstrate the use of a mutex:

#include <list> 
#include <mutex> 
#include <algorithm>

std::list<int> some_list; // A data structure accessed by multiple threads
std::mutex some_mutex; // This lock will prevent concurrent access to the shared data structure

void
add_to_list(int new_value) {
    std::lock_guard<std::mutex> guard(some_mutex); // Since I am going to access the shared data struct, acquire the lock
    some_list.push_back(new_value); // Now it is safe to use some_list. RAII automatically releases lock at end of function }
}

bool
list_contains(int value_to_find) {
    std::lock_guard<std::mutex> guard(some_mutex); // Must get lock every time I access some_list return
    std::find (some_list.begin(),some_list.end(),value_to_find) != some_list.end();
}

I think the code is somewhat self-explanatory but I had some specific questions.

1. Is there no need to specifically associate the mutex with the list?
2. And if not, does that mean that any time a mutex is used, all threads halt until the mutex is destroyed? Or is it only a subset of threads; perhaps threads in some threadpool or otherwise associated with each other?
3. And whichever is the case, isn't it better to only halt threads which are attempting to access the data structure? Because otherwise, we're not worried about data races and the like.
4. Finally, what's the difference between a mutex and a lock? Is a mutex simply an RAII lock? Or is the RAII happening via the guard?

Answer 1

1. The mutex is associated with the list, but this association is completely manual -- the compiler and runtime library do not know that the two are associated. The association exists entirely in your documentation and in your head, and you are responsible for ensuring that any thread which accesses the list locks/acquires the mutex first.

2. Whenever a mutex is used, the thread which locks/acquires the mutex will halt (the term is actually block) until no other thread owns the mutex. Threads which are not using the mutex will be unaffected.

3. You are responsible for ensuring that only the threads which access the list lock/acquire the mutex, and you are also responsible for ensuring that all of the threads which access the list lock/acquire the mutex. Again, only those threads can block waiting for the mutex.

4. The same object goes by a number of different names: "mutex", "lock", or "critical section". The guard uses RAII to lock/acquire the mutex.