Volatile does not guarantee thread safety

In DPDK, the operation of the atomic weight is encapsulated. Such as

1. typedefstruct{
2. volatileint32_t cnt;/**< An internal counter value. */
3. }rte_atomic32_t;

But a lot of people use it, often as follows

1. rte_atomic32_t pkt_count;
2. pkt_count.cnt +=......

This is actually very insecure in multi-threading. Example:

2. #include<pthread.h>
4. #include<stdio.h>
6. volatileint test=0;
8. //pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
10. void* print_xs (void* used)
12. {
14. //pthread_rwlock_wrlock(&rwlock);
16. test=test+2;
18. //pthread_rwlock_unlock(&rwlock);
20. sleep(1);
22. //pthread_rwlock_wrlock(&rwlock);
24. test=test+3;
26. //pthread_rwlock_unlock(&rwlock);
30. }
32. int main (){
34. pthread_t thread_id[100];
36. int data=0;
38. int i=0;
40. for(i=0; i<100; i++){
42. pthread_create (&(thread_id[i]), NULL, print_xs, NULL);
44. }
46. for(i=0; i<100; i++){
48. pthread_join(thread_id[i],NULL);
50. }
52. printf("%d\n",test);
54. return-1;
56. }

The test code, as above, defines thevOlatileand is executed without locking. Execution results are random, not 500. Excerpt from Wikipedia:in theProgramming, especially inC language,C++,C#and theJavalanguage, use the volatile keyword to declare theVariableorObjecttypically have special properties related to optimizations, multithreading. Usually, volatilekeywords are used to prevent (pseudo) compilers from being optimized for code that cannot be "changed by the code itself" (Variables/objects). In the C language, volatileThe keyword can be used to remind the compiler that variables defined later can change at any time, so the compiled program reads the data directly from the variable address each time it needs to store or read the variable. Without the volatile keyword, the compiler might optimize reading and storage, may temporarily use the value in the register, and if the variable was updated by another program, there would be an inconsistency .  

Null

Volatile does not guarantee thread safety