并发编程-并发三大特性
并发三大特性
并发编程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程序提供内存可见性的保证。
