并发三大特性
并发编程Bug源头:原子性、可见性和有序性问题。
原子性
一个或多个操作,要么全部执行且在执行过程中不被任何因素打断,要么全部不执行。
注意:不采取任何的原子性保障措施的自增操作并不是原子性的,比如i++操作。
原子性案例:
// 模拟多线程累加操作
public class AtomicTest
{
private static volatile int counter = 0;
public static void main(String[] args)
{
for (int i = 0; i < 10; i++)
{
Thread thread = new Thread(() -> {
for (int j = 0; j < 10000; j++)
{
counter++;
}
});
thread.start();
}
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
// 思考counter=?
System.out.println(counter);
}
}
未保证原子性,输出结果:
38865(随机值)
如何保证原子性
-
通过 synchronized 关键字保证原子性
-
通过 Lock锁保证原子性
-
通过 CAS保证原子性
思考:在 32 位的机器上对 long 型变量进行加减操作是否存在并发隐患?
存在安全隐患,32位机器上操作 long 类型分为两步:高32位、低32位,并发可能有脏读问题
可见性
当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。
可见性案例:
// 模拟两个线程对共享变量操作
public class VisibilityTest
{
// volatile -> lock addl $0x0,(%rsp)
// 1、volatile 保证可见性
private volatile boolean flag = true;
// private volatile int count;
public synchronized void refresh()
{
// 希望结束数据加载工作
flag = false;
System.out.println(Thread.currentThread().getName() + "修改flag:" + flag);
}
public void load()
{
System.out.println(Thread.currentThread().getName() + "开始执行.....");
while (flag)
{
// TODO 业务逻辑:加载数据
// 2、让出CPU时保证可见性,1000不会跳出循环,10000跳出,因为时间片用完了
// shortWait(10000);
// 3、synchronized 保证可见性
// System.out.println("正在加载数据......");
// 4、volatile count 保证可见性
// count++;
// 5、添加一个内存屏障,保证可见性
// UnsafeFactory.getUnsafe().storeFence();
// 6、sleep 保证可见性,方法内部使用了内存屏障
// try {
// Thread.sleep(0);
// } catch (InterruptedException e) {
// throw new RuntimeException(e);
// }
// 7、保证可见性
// 让出cpu使用权
// Thread.yield();
}
System.out.println(Thread.currentThread().getName() + "数据加载完成,跳出循环");
}
public static void main(String[] args) throws InterruptedException
{
VisibilityTest test = new VisibilityTest();
// 线程threadA模拟数据加载场景
Thread threadA = new Thread(() -> test.load(), "threadA");
threadA.start();
// 让threadA先执行一会儿后再启动线程B
Thread.sleep(1000);
// 线程threadB通过修改flag控制threadA的执行时间,数据加载可以结束了
Thread threadB = new Thread(() -> test.refresh(), "threadB");
threadB.start();
}
public static void shortWait(long interval)
{
long start = System.nanoTime();
long end;
do
{
end = System.nanoTime();
} while (start + interval >= end);
}
}
// Unsafe工具类
public class UnsafeFactory
{
/**
* 获取 Unsafe 对象
*/
public static Unsafe getUnsafe()
{
try
{
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
return (Unsafe)field.get(null);
}
catch (Exception e)
{
e.printStackTrace();
}
return null;
}
/**
* 获取字段的内存偏移量
*/
public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName)
{
try
{
return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
}
catch (NoSuchFieldException e)
{
throw new Error(e);
}
}
}
如何保证可见性
-
通过 volatile 关键字保证可见性
-
通过内存屏障保证可见性
-
通过 synchronized 关键字保证可见性
-
通过 Lock锁保证可见性
思考:为什么多线程对共享变量的操作存在可见性问题?
有序性
程序执行的顺序按照代码的先后顺序执行。为了提升性能,编译器和处理器常常会对指令做重排序,所以存在有序性问题。
有序性案例:
// 从代码顺序看,不会出现(0,0)的结果。指令重排序就有可能出现
public class ReOrderTest
{
private static int x = 0, y = 0;
private static int a = 0, b = 0;
public static void main(String[] args) throws InterruptedException
{
int i = 0;
while (true)
{
i++;
x = 0;
y = 0;
a = 0;
b = 0;
/**
* x,y的值是多少: 0,1 1,0 1,1 0,0
*/
Thread thread1 = new Thread(new Runnable()
{
@Override
public void run()
{
a = 1;
x = b;
}
});
Thread thread2 = new Thread(new Runnable()
{
@Override
public void run()
{
b = 1;
y = a;
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("第" + i + "次(" + x + "," + y + ")");
if (x == 0 && y == 0)
{
break;
}
}
}
}
如何保证有序性
-
通过 volatile 关键字保证有序性
-
通过内存屏障保证有序性
-
通过 synchronized关键字保证有序性
-
通过Lock锁保证有序性
Java内存模型
在并发编程中,需要处理的两个关键问题:
1)多线程之间如何通信(线程之间以何种机制来交换数据)
2)多线程之间如何同步(控制不同线程间操作发生的相对顺序)
线程之间常用的通信机制有两种:共享内存和消息传递,Java采用的是共享内存模型
Java内存模型的抽象结构
Java线程之间的通信由Java内存模型(Java Memory Model,简称JMM)控制,JMM决定一个线程对共享变量的写入何时对另一个线程可见。
JMM定义了线程和主内存之间的抽象关系:线程之间的共享变量存储在主内存中,每个线程都有一个私有的本地内存,本地内存中存储了共享变量的副本。本地内存是JMM的一个抽象概念,并不真实存在,它涵盖了缓存,写缓冲区,寄存器以及其他的硬件和编译器优化。
根据JMM的规定,线程对共享变量的所有操作都必须在自己的本地内存中进行,不能直接从主内存中读取。JMM通过控制主内存与每个线程的本地内存之间的交互,来为Java程序提供内存可见性的保证。