并发编程的3个重要概念
1.原子性：
一个操作或者多个操作，要么全部成功，要么全部失败
1.java中保证了基本数据类型的读取和赋值,保证了原子性,这些操作不可终端
a=10 原子性 b=a 不满足 1.read a; 2.assign b; c++ 不满足 1.read c; 2 add 3.assige to c c=c+1 不满足 1.read c 2.add; 3. assign to c;
2.可见性：
volatile 可以保证可见性.主要是把变量放在主存里
多个线程访问这个变量，一个线程修改之后必须保证另一个线程可以看见。
每一个线程都自己的缓存，有的变量在主存区，我们要保证变量的可见性
4.顺序性：
java中hapens-before 原则保证了有序性
4.1 代码顺序(程序顺序规则): 单个线程中的每个操作 编写在前面的反生在编写在后面的
4.2 lock原则(监视器锁规则) : unlock 必须发生在lock之后
4.3 volatile变量规则: 对该变量的写操作必须发生在读操作之前.就是一个变量 写变量发生在读变量之前
4.4 传递规则: a->b->c 那么a肯定在c之前
4.5 start规则: 先start 线程在启动(个人认为废话)
4.6 中断规则: 对线程的中断 先发生在 捕获interpetor异常之前(个人认为废话)
4.7 对象的销毁规则: 一个对象的初始化.必须发生在finalize 之前(个人认为废话)
4.8 线程的终结规则: 所有操作都发生在线程死亡之前 (个人认为废话)
比如定义一个变量
int i =0; boolean flag =false; int i =1; boolean flag =true; java中有重排序的过程 因为这几条代码没有关联性可能会变成 int i =0; boolean flag =false; boolean flag =true; int i =1;
重排序只保证最终一致性，重排序也是有依赖关系的，重排序对没有依赖关系的可以重排序 ，重排序不会影响单线程，但是会影响多线程
举个例子
--------thread-1 ==========
obj =createObj();1
flag = true; 2
如果这里发生指令重排将 1 -2 顺序颠倒下面下面的代码就会报出空指针异常
-----thread-2------
while(!flag){
}
useObject()
atomic 具有原子性
主要有俩点 1.他的变量是volatile
2.unsafe方法调用
// setup to use Unsafe.compareAndSwapInt for updates private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; static { try { valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } private volatile int value;
什么时候需要使用atomic类对象
当多线程操作一个变量的时候。如果使用传统的变量会出错，很多同学为了解决这个问题，加了votatile修饰。也并不能够解决问题。
补充下votalite 的知识
volatile具有可见性、有序性，不具备原子性。
当value+=1时候我们需要做几个操作
1.从主存区获取变量到写存区
2.value+1
3.value = 新的value
4.讲变量写入主存区
这4步都是原子性的。但是在多线程环境中。可能你读取到的变量是别人修改过的变量造成线程不安全情况
private static Set<Integer> set = Collections.synchronizedSet(new HashSet<>()); public static void main(String[] args) throws InterruptedException { Thread t1= new Thread(()->{ int x=0; while (x<500){ set.add(value); int temp =value; System.out.println(Thread.currentThread().getName()+" "+temp); value +=1; x++; } }); Thread t2= new Thread(()->{ int x=0; while (x<500){ set.add(value); int temp =value; System.out.println(Thread.currentThread().getName()+" "+temp); value +=1; x++; } }); Thread t3= new Thread(()->{ int x=0; while (x<500){ set.add(value); int temp =value; System.out.println(Thread.currentThread().getName()+" "+temp); value +=1; x++; } }); t1.start(); t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); System.out.println(set.size()); 」
当我们使用aomic类时。可以保证原子性
AtomicInteger atoValue = new AtomicInteger(); Thread t1= new Thread(()->{ int x=0; while (x<500){ int i = atoValue.getAndIncrement(); set.add(i); System.out.println(Thread.currentThread().getName()+" "+i); atoValue.getAndIncrement(); x++; } }); Thread t3= new Thread(()->{ int x=0; while (x<500){ int i =atoValue.getAndIncrement(); set.add(i); System.out.println(Thread.currentThread().getName()+" "+i); atoValue.getAndIncrement(); x++; } }); Thread t2= new Thread(()->{ int x=0; while (x<500){ int i = atoValue.getAndIncrement(); set.add(i); System.out.println(Thread.currentThread().getName()+" "+i); x++; } }); t1.start(); t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); System.out.println(set.size());
下载jdk源码
http://download.java.net/openjdk/jdk8/promoted/b132/openjdk-8-src-b132-03_mar_2014.zip
源码查看
/openjdk/jdk/src/share/classes/sun/misc/Unsafe.java
atomic保证原子性操作是因为有unsafe.java
很多人都说unsafe.java 是java留的一后门可以直接操作cpu级别的内存
因为UnSafe提供了硬件级别的原子操作，提高了Java对底层操作的能力。Unsafe类使Java语言拥有了像C语言的指针一样的操作内存空间的能力
一篇比较好的博客
https://www.cnblogs.com/pkufork/p/java_unsafe.html
如何保证原子性
/** * Atomically adds the given value to the current value of a field * or array element within the given object <code>o</code> * at the given <code>offset</code>. * * @param o object/array to update the field/element in * @param offset field/element offset * @param delta the value to add * @return the previous value * @since 1.8 */
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
1、需要修改的对象
2、更改属性的内存偏移量
4、要添加的 1
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
}
while (!compareAndSwapInt(o, offset, v, v + delta)); return v;
}
其实主要原子性是通过compareAndSwapInt对比算法.传入你开始的值.和预期的值 如果不相同就一直执行下去直到相同为止,达到很多人说的无锁概念,其实我更倾向于自旋锁
假设多线程调用getAndIncrement
假设初始值是1
compareAndWapInt(1,1+1) |
compareAndWapInt(1,1+1) |
|
1 2 比较false 进行下一次 2==2 2 |
1 2比较 false 2 3 比较false 3 |
这样就实现了free lock
获取unsafe.实例利用java反射
Field f = Unsafe.class.getDeclaredField("theUnsafe"); f.setAccessible(true); Unsafe unsafe = (Unsafe) f.get(null);
自己测试类
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { Field f1 = Unsafe.class.getDeclaredField("theUnsafe"); f1.setAccessible(true); Unsafe unsafe = (Unsafe) f1.get(null); Class clazz = Target.class; Field[] fields = clazz.getDeclaredFields(); for (Field f : fields) { // 获取属性偏移量，可以通过这个偏移量给属性设置 System.out.println(f.getName() + ":" + unsafe.objectFieldOffset(f)); } Target target = new Target(); Field intFiled = clazz.getDeclaredField("intParam") ; // int a=(Integer)intFiled.get(target ) ; // System.out.println("原始值是:"+a); //intParam的字段偏移是12 原始值是3 我们要改为10 System.out.println(unsafe.compareAndSwapInt(target, 12, 3, 10)); int b=(Integer)intFiled.get(target) ; System.out.println("改变之后的值是:"+b); // // //这个时候已经改为10了,所以会返回false System.out.println(unsafe.compareAndSwapInt(target, 12, 3, 10)); // // System.out.println(unsafe.compareAndSwapObject(target, 24, null, "5")); } } class Target { int intParam=3; long longParam; String strParam; String strParam2; }