文章目录

可见性定义：

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

原子性的定义：

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

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

Synchronized：保证可见性和原子性

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

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

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