Effective Modern C++:constexpr, thread safe

constexpr is more strict than const

int a;
const b = a;//correct
constexpr c = a;//wrong, because a has no value yet

When declaring a constexpr, it should be assigned with a already existed value.

you can get compile-time result when using constexpr function

Amazing, no debugging needed, when you are codding, you already know the result.

Thread safe programming

Use lock_guard to keep the whole function thread safe:

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;

class busy
{
public:
	void compute(int a)
	{
		lock_guard<mutex> guard(m);//keep safe here
		cout << a <<" "<< curr << endl;
		curr += 1.0;
	}
private:
    double curr = 3.0;
	mutable mutex m;
};

busy bus;

void thread1()
{
	for (int i = 0; i < 10; i++)
		bus.compute(1);
}
void thread2()
{
	for (int i = 0; i < 10; i++)
		bus.compute(2);
}
void main()
{
	thread t1(thread1);
	thread2();
	t1.join();
}

The mutex and lock_guard is used to keep the thread save.

If we don’t use mutex and lock_guard, everything will get crazy:

1 3
2 3
1 4
1 5
2 6
2 8
2 1 7
9
2 11
1 10
2 12
1 13
1 2 14
15
2 1 16
17
2 1 19
18
1 20
2 21

Using mutex and lock_guard, the output is like this:

1 3
1 4
1 5
1 6
1 7
1 8
1 9
1 10
1 11
1 12
2 13
2 14
2 15
2 16
2 17
2 18
2 19
2 20
2 21
2 22

Use atomic to keep a single variable thread safe:

mutable std::atomic<int> callCount{ 0 };

Just wrap the variable as above, it becomes thread safe.