Summary: comparison between the security thread described herein, atomic, and the package under the category java.lang.Number CAS operation, the synchronized locks, and each of the atomic operation.
Thread safety
Thread-safe?
Thread safety?
Atomicity
Atomic package classes and CAS:
AtomicInteger
AtomicLong and LongAdder
AtomicBoolean
AtomicIntegerFieldUpdater
AtomicStampReference the ABA problem with CAS
AtomicLongArray
synchronized
a synchronized block of code modification
modification of a synchronized method
synchronized modification of a static method
synchronized modification of a class
Comparison among atomic operations
Thread-safe?
When multiple threads access a class, regardless of the runtime environment using what scheduling or how these processes will be performed alternately, and in the calling code does not require any additional synchronization or synergistic , this class can show the correct behavior , then call this class is thread-safe.
Thread safety?
Thread safety is mainly reflected in three aspects: atomicity, visibility, orderly
Atomic: provides exclusive access , only one thread at a time to operate it
Visibility: main memory modify a thread can be observed in time to other threads
Ordering: a thread other threads observation instruction execution order, since there is an instruction reordering, the general observation disorderly.
The basis of the code: The following code is used to describe knowledge points below, all of the code are to be modified in this code basis.
// total number of requests public static int clientTotal = 5000; threads executing several concurrent // public static int = 200 is threadTotal; // declare variables: counts public static AtomicInteger count = new AtomicInteger ( 0);
static void main public (String [] args) {throws InterruptedException ExecutorService Executors.newCachedThreadPool ExecutorService = (); // Create a thread pool final Semaphore semaphore = new Semaphore (threadTotal ); // define semaphore allows concurrent given number of final CountDownLatch countDownLatch = new CountDownLatch (clientTotal) ; // define the counter latch for (int I = 0; I <clientTotal; I ++) { executorService.execute (() -> { the try { Semaphore.acquire (); // determines whether the process is allowed to perform the Add (); semaphore.release (); // process the release of } the catch (InterruptedException E) { log.error ( "excption", E); } countDownLatch.countDown (); }); } CountDownLatch.await (); // to ensure signal minus 0 executorService.shutdown (); // Close thread pool log.info ( "count: {}" , count.get ( )); // variable value }
Speaking of atomicity, a total of two aspects need to learn about, is a JDK already provide good Atomic package, they are using the atomic operations CAS complete thread, and the other is to use the lock mechanism to handle between threads atomicity. Lock include: synchronized, Lock
Atomic package classes and CAS:
We AtomicInteger class from the simplest to understand what is CAS
AtomicInteger
The sample code is to ensure that the upper side of the thread by atomic AtomicInteger class. So how does it guarantee the atomicity of it? We then analyze its source. Example, +1 to the count variable, uses incrementAndGet method, the source of this method calls a method named the unsafe.getAndAddInt
1 2 3
public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; }123
而getAndAddInt方法的具体实现为：
1 2 3 4 5 6 7
public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; }1234567
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5); public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);123
public final boolean compareAndSet(boolean expect, boolean update) { int e = expect ? 1 : 0; int u = update ? 1 : 0; return unsafe.compareAndSwapInt(this, valueOffset, e, u); }12345
//是否发生过 private static AtomicBoolean isHappened = new AtomicBoolean(false); // 请求总数 public static int clientTotal = 5000; // 同时并发执行的线程数 public static int threadTotal = 200;
public static void main(String[] args) throws Exception { ExecutorService executorService = Executors.newCachedThreadPool(); final Semaphore semaphore = new Semaphore(threadTotal); final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); for (int i = 0; i < clientTotal ; i++) { executorService.execute(() -> { try { semaphore.acquire(); test(); semaphore.release(); } catch (Exception e) { log.error("exception", e); } countDownLatch.countDown(); }); } countDownLatch.await(); executorService.shutdown(); log.info("isHappened:{}", isHappened.get()); }
源码： private static class Pair<T> { final T reference; final int stamp; private Pair(T reference, int stamp) { this.reference = reference; this.stamp = stamp; } static <T> Pair<T> of(T reference, int stamp) { return new Pair<T>(reference, stamp); } }
public class SynchronizedExample { public void test(int j){ synchronized (this){ for (int i = 0; i < 10; i++) { log.info("test - {} - {}",j,i); } } } //使用线程池方法进行测试： public static void main(String[] args) { SynchronizedExample example1 = new SynchronizedExample(); SynchronizedExample example2 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(()-> example1.test(1)); executorService.execute(()-> example2.test(2)); } }1234567891011121314151617
结果：不同对象之间的操作互不影响
synchronized 修饰一个方法
被修饰的方法称为同步方法，作用的范围是大括号括起来的部分，作用的对象是调用这段代码的对象。 验证：
1 2 3 4 5 6 7 8 9
public class SynchronizedExample public synchronized void test(int j){ for (int i = 0; i < 10; i++) { log.info("test - {} - {}",j,i); } } //验证方法与上面相同 ... }123456789
public class SynchronizedExample{ public static synchronized void test(int j){ for (int i = 0; i < 10; i++) { log.info("test - {} - {}",j,i); } } //验证方法与上面相同 ... }123456789
结果：同一时间只有一个线程可以执行
synchronized 修饰一个类
验证：
1 2 3 4 5 6 7 8 9 10 11
public class SynchronizedExample{ public static void test(int j){ synchronized (SynchronizedExample.class){ for (int i = 0; i < 10; i++) { log.info("test - {}-{}",j,i); } } } //验证方法与上面相同 ... }1234567891011
Results: Only one thread can execute
Comparison among atomic operations
synchronized: the lock can not be interrupted for less competitive, good readability
Lock: interruptible lock, with manifold, to maintain normal when fierce competition
Atomic: when fierce competition to maintain normal, better than the performance Lock, you can only synchronize one value
