原子性or可见性 - volatile_Or_synchronized - AtomicInteger 测试

可见性定义：

一个线程对共享变量的修改，更够及时的被其他线程看到

原子性的定义：

原子操作（atomic operation）是不需要synchronized，这是Java多线程编程的老生常谈了。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。

即不可再分了，不能分为多步操作。比如赋值或者return。比如"a = 1;"和 "return a;"这样的操作都具有原子性。类似"a += b"这样的操作不具有原子性，在某些JVM中"a += b"可能要经过这样三个步骤：
①　取出a和b
②　计算a+b
③　将计算结果写入内存

Synchronized：保证可见性和原子性

Volatile：保证可见性，但不保证操作的原子性

Synchronized能够实现原子性和可见性；在Java内存模型中，synchronized规定，线程在加锁时，先清空工作内存→在主内存中拷贝最新变量的副本到工作内存→执行完代码→将更改后的共享变量的值刷新到主内存中→释放互斥锁。

volatile 修饰循环跳出条件

起作用了。
https://blog.csdn.net/LawssssCat/article/details/103135820#_volatile__1232

volatile 修饰计数器

1000线程对int自加

package cn.edut.com.test;

import java.util.Iterator;
import java.util.LinkedList;

public class Test0002 {
	static  Integer n  =0; 
	public static void main(String[] args) throws Exception {
		LinkedList<Thread> list = new LinkedList<Thread>(); 
		for(int i=0 ;i<1000 ; i++ ) {
			Thread t = new Thread() {
				public void run() {
					n++;
				};
			};
			list.add(t);
			t.start();
		}
		
		Iterator<Thread> it = list.iterator();
		while(it.hasNext()) {
			it.next().join();
		}
		
		System.out.println(n);
	}
}

1000线程对int自加（加volatile）

package cn.edut.com.test;

import java.util.Iterator;
import java.util.LinkedList;

public class Test0002 {
	static volatile Integer n  =0; 
	public static void main(String[] args) throws Exception {
		LinkedList<Thread> list = new LinkedList<Thread>(); 
		for(int i=0 ;i<1000 ; i++ ) {
			Thread t = new Thread() {
				public void run() {
					n++;
				};
			};
			list.add(t);
			t.start();
		}
		
		Iterator<Thread> it = list.iterator();
		while(it.hasNext()) {
			it.next().join();
		}
		
		System.out.println(n);
	}
}

1000线程对int自加（加锁 - synchronize）

package cn.edut.com.test;

import java.util.Iterator;
import java.util.LinkedList;

public class Test0002 {
	static  Integer n  =0; 
	static Object lock_n =new Object();
	public static void main(String[] args) throws Exception {
		LinkedList<Thread> list = new LinkedList<Thread>(); 
		for(int i=0 ;i<1000 ; i++ ) {
			Thread t = new Thread() {
				public void run() {
					synchronized (lock_n) {
						n++;
					}
				};
			};
			list.add(t);
			t.start();
		}
		
		Iterator<Thread> it = list.iterator();
		while(it.hasNext()) {
			it.next().join();
		}
		
		System.out.println(n);
	}
}

Note:

• 这里不能拿n作为锁，否则的话，小概率结果不准确。

1000线程对AtomicInteger自加

AtomicInteger测试

		AtomicInteger i = new AtomicInteger();
		System.out.println(i);
		i.incrementAndGet();
		System.out.println(i);

1000线程对AtomicInteger自加

package cn.edut.com.test;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

public class Test99 {
	public static void main(String[] args) throws Exception {
		AtomicInteger n = new AtomicInteger();
		LinkedList<Thread> list = new LinkedList<Thread>(); 
		for(int i=0 ;i<1000 ; i++ ) {
			Thread t = new Thread() {
				public void run() {
						n.incrementAndGet();
				};
			};
			list.add(t);
			t.start();
		}
		
		Iterator<Thread> it = list.iterator();
		while(it.hasNext()) {
			it.next().join();
		}
		
		System.out.println(n);
	}
}

总结

• volatile - 可见性（有）、原子性（没有）、不可修饰（ 多线程）计数器
• synchronized - 可见性（有）、原子性（有）、可以作为计数器（但开销大）
• 计数器解决方案 - AtomicInteger - 既可见又原子、还能减少开销