并发编程-并发三大特性

news2024/11/26 1:55:20

并发三大特性

并发编程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;
            }
        }
    }
}