Page History

Note
This page was automatically generated and should not be edited.

Note
The information on this page was provided by outside contributors and has not been verified by SEI CERT.

Tip
The table below can be re-ordered, by clicking column headers.

...

Include Page

	ThreadSafe_V
	ThreadSafe_V

Checker	Guideline
CCE_CC_CALLBACK_ACCESS	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_CC_CALLBACK_ACCESS	VNA01-J. Ensure visibility of shared references to immutable objects
CCE_CC_CALLBACK_ACCESS	VNA02-J. Ensure that compound operations on shared variables are atomic
CCE_CC_CALLBACK_ACCESS	VNA05-J. Ensure atomicity when reading and writing 64-bit values
CCE_CC_ITER_VIEW_BOTH_LOCKS	LCK04-J. Do not synchronize on a collection view if the backing collection is accessible
CCE_CC_ITER_VIEW_NO_LOCK	LCK04-J. Do not synchronize on a collection view if the backing collection is accessible
CCE_CC_ITER_VIEW_WRONG_LOCK	LCK04-J. Do not synchronize on a collection view if the backing collection is accessible
CCE_CC_NON_ATOMIC_CP	VNA03-J. Do not assume that a group of calls to independently atomic methods is atomic
CCE_CC_NON_ATOMIC_GCP	VNA03-J. Do not assume that a group of calls to independently atomic methods is atomic
CCE_CC_REUSEDOBJ_SYNC	LCK01-J. Do not synchronize on objects that may be reused
CCE_CC_SYNC_ON_VIEW	LCK04-J. Do not synchronize on a collection view if the backing collection is accessible
CCE_CC_UNSAFE_CONTENT	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_CC_UNSAFE_CONTENT	VNA01-J. Ensure visibility of shared references to immutable objects
CCE_CC_UNSAFE_CONTENT	VNA02-J. Ensure that compound operations on shared variables are atomic
CCE_CC_UNSAFE_CONTENT	VNA05-J. Ensure atomicity when reading and writing 64-bit values
CCE_CC_UNSAFE_ITERATION	VNA03-J. Do not assume that a group of calls to independently atomic methods is atomic
CCE_DL_DEADLOCK	LCK07-J. Avoid deadlock by requesting and releasing locks in the same order
CCE_FF_VOLATILE	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_FF_VOLATILE	VNA05-J. Ensure atomicity when reading and writing 64-bit values
CCE_LK_LOCKED_BLOCKING_CALLS	LCK09-J. Do not perform operations that can block while holding a lock
CCE_LK_REPLACE_WITH_TRYLOCK	VNA03-J. Do not assume that a group of calls to independently atomic methods is atomic
CCE_LK_UNRELEASED_ON_EXN	LCK08-J. Ensure actively held locks are released on exceptional conditions
CCE_SL_INCONSISTENT	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_SL_INCONSISTENT	VNA01-J. Ensure visibility of shared references to immutable objects
CCE_SL_INCONSISTENT	VNA02-J. Ensure that compound operations on shared variables are atomic
CCE_SL_INCONSISTENT	VNA05-J. Ensure atomicity when reading and writing 64-bit values
CCE_SL_INCONSISTENT_COL	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_SL_INCONSISTENT_COL	VNA01-J. Ensure visibility of shared references to immutable objects
CCE_SL_INCONSISTENT_COL	VNA02-J. Ensure that compound operations on shared variables are atomic
CCE_SL_INCONSISTENT_COL	VNA05-J. Ensure atomicity when reading and writing 64-bit values
CCE_SL_MIXED	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_SL_MIXED	VNA01-J. Ensure visibility of shared references to immutable objects
CCE_SL_MIXED	VNA02-J. Ensure that compound operations on shared variables are atomic
CCE_SL_MIXED	VNA05-J. Ensure atomicity when reading and writing 64-bit values
CCE_SL_MIXED_COL

Info

title	Generated Content

This page is automatically generated from the "Automated Detection" sections in the individual guidelines. Do not modify this page directly.

Java checkers	Rule
The serializable class .* does not declare a static final serialVersionUID field of type long	OBJ10-J. Do not use public static nonfinal variables
	VNA00-J. Ensure visibility when accessing shared primitive variables
CCE_SL_MIXED_COL	VNA01-J. Ensure visibility of shared references to immutable objects
CCE_SL_MIXED_COL	VNA02-J. Ensure that compound operations on shared variables are atomic
CCE_SL_MIXED_COL	VNA05-J. Ensure atomicity when reading and writing 64-bit values

Space shortcuts

Page tree

Versions Compared

Old Version 1

New Version Current

Key