Ensuring the correctness of multi-threaded programs is difficult, due to the potential for unexpected and nondeterministic interactions between threads. In the past, researchers have addressed this problem by devising tools for detecting race conditions, a situation where two threads simultaneously access the same data variable, and at least one of the accesses is a write. However, verifying the absence of such simultaneous-access race conditions is neither necessary nor sufficient to ensure the absence of errors due to unexpected thread interactions. A stronger non-interference property, namely atomicity, is required. A method is atomic if its execution is not affected by and does not interfere with concurrently executing threads. Precisely, a method (or in general a code block) is atomic if for every (arbitrarily interleaved) program execution, there is an equivalent execution with the same overall behavior where the atomic method is executed serially, that is, the method's execution is not interleaved with actions of other threads. This report discusses two methods of atomicity checking, namely static and dynamic checking. Type system is for specifying and verifying the atomicity of methods in multithreaded programs. Dynamic analysis is used to find out atomicity violations in multithreaded softwares. For run-time analysis two algorithms reduction-based algorithm and block-based algorithm are discussed.