并发编程中三个基础概念(原子性,可见性,有序性)的理解与实践

并行编程中三个基础概念(原子性,可见性,有序性)的理解与实践

在分析线程安全问题时，需要理解在并行编程中的三个基础概念，即原子性(Atomicity),可见性(Visibility)以及有序性(Ordering)。

原子性

原子性简介

即一个操作或者多个操作,要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

原子性的概念与数据库中的原子性概念一致，最适合用银行转账的例子来描述。

例如从账户A转出100元到账户B，可以分解为以下操作:

  1. 读取账户A的余额,300
  2. 计算账户A余额减去100后的余额,得到200
  3. 更新账户A的余额为200
  4. 读取账户B的余额,500
  5. 计算账户B的余额加上100后的余额，得到600
  6. 更新账户B的余额为600

以上操作要么全部成功，要么全部失败，不能出现执行到某一个步骤然后停止的情况，例如执行完第3步后忽然停止，那么账户A已经减少了100元，而账户B却没有任何增加。

原子性问题示例

在Java中典型的原子性问题就是变量的自加自减操作，例如count++操作看起来只是一个操作，但其实包含了三个独立的操作：读取count的值，将值加1，然后将计算结果写入count。

例如我们编写一个计数器，用来记录当日登录系统的用户数量，如程序清单所示:

public class NonAtomicityDemo {
    public static void main(String[] args) {
        int i = 10;
        while (i-- > 0) {
            new Thread(() -> UnSafeCounter.addCount()).start();
        }
    }
}

class UnSafeCounter {
    private static int counter = 0;

    public static void addCount() {
        counter++;
        System.out.println(counter);
    }

}

/**
 * 输出
 * 4
 * 10
 * 8
 * 9
 * 8
 * 6
 * 7
 * 4
 * 4
 * 5
 */

我们可以观察到,开启10个线程调用UnSafeCounter的addCount()方法，输出的计数是错误的，这是因为count++操作并不是原子操作的原因，不同的线程可能获取count值时，count已经被另一个线程进行了赋值，而当前线程输出的仍然是未被改变的值。这种多个线程多次调用中返回错误的值将导致严重的数据完整性问题。在并发编程中，这种由于不恰当的执行时序而出现的不正确结果情况有一个正式的名字：竟态条件(Race Condition)。

如何解决原子性问题

在程序有数据完整性问题的时候，一般如何解决呢？其实只要保证操作是符合原子性的，那么就可以避免数据不一致的情况。

假定有两个操作A和B，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B，那么A和B对彼此来说是原子的。原子操作是指，对于访问同一个状态的所有操作（包括该操作本身）来说，这个操作是一个以原子方式执行的操作。

一般我们可以通过以下几种方法来保证操作的原子性。

  1. 通过synchronized关键字来保证同步

    
public class AtomicityBySynchronizedDemo {
    public static void main(String[] args) {
        int i = 10;
        while (i-- > 0) {
            new Thread(() -> UnSafeCounter.addCount()).start();
        }
    }
}


class SafeCounter {
    private static int counter = 0;

    //synchronized关键字修饰
    public static synchronized void addCount() {
        counter++;
        System.out.println(counter);
    }

}
/**
* 输出,有序
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
*/

    通过对addCount()方法用synchronized关键字修饰来实现加锁，这样线程在争夺执行权时必须要先获得锁,当线程获得锁后其他的线程都只能等待锁的释放，这样就保证了addCount操作的原子性。
    例如:

    1. T1时刻，线程A获得SafeCounter.class的锁，开始执行addCount方法，这时，其他的线程都进入等待状态，无法执行addCount()方法
    2. T2时刻，线程A执行addCount()方法结束，释放SafeCounter.class的锁，其他的线程争夺锁
    3. T3时刻，线程B获得锁，并执行addCount()方法，其他线程等待，无法执行addCount()方法
    4. T4时刻，线程B执行addCount()方法结束，释放SafeCounter.class的锁，其他的线程争夺锁
    5. ....往复上述过程，直到程序正常退出

  2. 通过原子类来保证数据同步
    concurrent包下提供了一些原子类，如：AtomicInteger、AtomicLong、AtomicReference等这些类提供了原子操作。

    例如:

    
public class AtomicityByAtomicIntegerDemo {
    public static void main(String[] args) throws InterruptedException {
        int i = 10;
        while (i-- > 0) {
            new Thread(() -> SafeCounter.addCount()).start();
        }
        Thread.sleep(3000);//等待子线程执行结束
        System.out.println(SafeCounter.counter);
        //输出10
    }


    static class SafeCounter {
        private static AtomicInteger counter = new AtomicInteger(0);

        public static void addCount() {
            counter.incrementAndGet();//对比count++,counter.incrementAndGet()是原子操作，而count++不是原子操作
        }

    }
}

  3. Lock显式锁来进行同步
    //TODO

竟态条件(Race Condition)

当某个计算的正确性取决于多个线程的交替执行时序时，那么就会发生竞态条件。例如计数器Demo中的addCount()方法，addCount的正确性取决于对count进行+1操作和输出count的值必须是顺序执行的，但是不同的线程同时执行addCount()方法时，线程争夺执行权的过程中产生竟态条件。例如：

  1. 在T1时刻线程A读取了count的值=4，然后交出了执行权
  2. 在T2时刻线程B获得了执行权也读取了count的值=4,线程B对count进行+1操作，然后输出count的值为5并交出执行权
  3. 在T3时刻，线程A继续执行将count(值为4)进行+1操作，输出count的值为5并交出执行权
  4. 这就是多个线程交替执行，由于执行的时序，而产生的竟态条件问题。

那么如何解决竟态条件问题呢?

我们称导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。在临界区一般通过使用synchronized或者Lock显式锁来对代码进行同步，这样来解决竟态条件问题。

可见性(Visibility)

线程可见性简介

线程之间的可见性是指当一个线程修改一个变量，另外一个线程可以马上得到这个修改值。

假设我们有2个线程：A为读线程，读取一个共享变量的值，并根据读取到的值来判断下一步执行逻辑；B为写线程，对一个共享变量进行写入。很有可能B线程写入的值对于A线程是不可见的。

两个线程间的不可见性

我们用一个例子来表示这种线程间变量不可见的情况。Nonvisibility中的示例包含两个共享数据的线程。写线程将更新标志，读线程将等待直到设置标志：

package com.random.jcp.base.thread.nature.visibility;


public class NonVisibilityDemo {
    public static void main(String[] args) throws InterruptedException {
        new ReadThread().start();
        Thread.sleep(1000);
        new WriteThread().start();
    }
}


class ReadThread extends Thread {

    @Override
    public void run() {
        System.out.println("read-thread start");
        while (true) {
            if (ShareData.flag == 1) {
                System.out.println("read-thread end");
                break;
            }
        }
    }
}

class ShareData {
    public static int flag = -1;
}


class WriteThread extends Thread {
    @Override
    public void run() {
        ShareData.flag = 1;
        System.out.println("write-thread:flag=" + ShareData.flag);
    }
}

这个程序可能会一直循环下去，因为读线程可能读取不到写线程对于flag的写入而永远等待。

NonVisibilityDemo

如何解决线程间不可见性

为了保证线程间可见性我们一般有3种选择:

  • volatile:只保证可见性
  • Atomic相关类:保证可见性和原子性
  • Lock: 保证可见性和原子性

使用volatile关键字来解决可见性问题

我们尝试更改上一个示例,使用volatile关键字来修饰共享数据ShareData.flag

public class VisibilityByVolatileDemo {
    public static void main(String[] args) throws InterruptedException {
        new ReadThread().start();
        Thread.sleep(1000);
        new WriteThread().start();
    }

    static class ShareData {
        //使用volatile关键字修饰
        public static volatile int flag = -1;
    }

    static class ReadThread extends Thread {

        @Override
        public void run() {
            System.out.println("read-thread start");
            while (true) {
                if (ShareData.flag == 1) {
                    System.out.println("read-thread end");
                    break;
                }
            }
        }
    }

    static class WriteThread extends Thread {
        @Override
        public void run() {
            ShareData.flag = 1;
            System.out.println("write-thread:flag=" + ShareData.flag);
        }
    }
}

由于对ShareData.flag使用了volatile关键字进行了修饰，程序可以正常结束，并且读线程可以正常的访问到写线程对共享数据flag的修改从而正常结束。

VisibilityDemo

使用AtomicInteger类来解决可见性问题

我们再尝试更改上一个示例,使用AtomicInteger类来包装共享数据ShareData.flag:


import java.util.concurrent.atomic.AtomicInteger;

public class VisibilityByAtomicDemo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("\nVisibilityByAtomicDemo");
        new ReadThread().start();
        Thread.sleep(1000);
        new WriteThread().start();
    }

    static class ShareData {
        public static AtomicInteger flag = new AtomicInteger(-1);
        private static volatile AtomicBoolean ready = new AtomicBoolean(false);

    }

    static class ReadThread extends Thread {

        @Override
        public void run() {
            System.out.println("read-thread start");
            while (true) {
                if (ShareData.flag.get() == 1) {
                    System.out.println("read-thread end");
                    break;
                }
            }
        }
    }

    static class WriteThread extends Thread {
        @Override
        public void run() {
            ShareData.flag.set(1);
            System.out.println("write-thread:flag=" + ShareData.flag);
        }
    }
}

由于ShareData.flag使用的类型是AtomicInteger,写线程对flag的修改对于读线程是可见的，这样写线程可以读取到flag被更新为1并正常退出。

VisibilityByAtomicDemo

使用synchronized来解决可见性问题

使用synchronized关键字对操作加锁也可以保证线程间的可见性，并且保证操作的原子性。
我们再构造一个示例来说明synchronized关键字所起的作用。首先我们还是需要2个线程，一个读线程，一个写线程，然后把读写操作封装到ShareData中，然后观察在没有synchronized关键字修饰时程序
的运行情况。


public class NonVisibilityDemo2 {

    public static void main(String[] args) throws InterruptedException {
        Thread writeThread = new Thread(() -> {
            System.out.println("start write");
            ShareData.write(100);
            System.out.println("end write");
        });

        Thread readThread = new Thread(() -> {
            while (true) {
                if (ShareData.read() == 100) {
                    System.out.println("read it");
                    break;
                }
            }
        });

        readThread.start();
        Thread.sleep(1000);
        writeThread.start();

    }


    static class ShareData {
        public static int flag = 0;

        public static int read() {
            return flag;
        }

        public static void write(int value) {
            flag = value;
        }

    }
}
/**
 * 输出：
 * start write
 * end write
 **/

可以观察到程序并不停止，读线程没有读取到写线程对ShareData.flag的写入操作。写线程对flag的写入对于读线程不可见。

我们更改这个示例，使用synchronize关键字对ShareData的read()方法和write()方法进行加锁操作。这样保证ShareData.flag对于读写线程都是可见的。


public class VisibilityBySynchronizedDemo {


    public static void main(String[] args) throws InterruptedException {
        System.out.println("\nVisibilityBySynchronizedDemo\n");
        Thread writeThread = new Thread(() -> {
            System.out.println("start write");
            ShareData.write(100);
            System.out.println("end write");
        });

        Thread readThread = new Thread(() -> {
            System.out.println("reading...");
            while (true) {
                if (ShareData.read() == 100) {
                    System.out.println("read it");
                    break;
                }
            }
        });

        readThread.start();
        Thread.sleep(1000);
        writeThread.start();

    }


    static class ShareData {
        public static volatile int flag = 0;

        public static synchronized int read() {
            return flag;
        }

        public static synchronized void write(int value) {
            flag = value;
        }

    }
}
/**
 * 输出：
 * VisibilityBySynchronizedDemo
 *
 * reading...
 * start write
 * end write
 * read it
 **/

由于read()方法和write()方法都使用了synchronized关键字修饰，保证了原子性和可见性，程序正常结束并且输出read it。

线程间的不可见性是怎样产生的

TODO

Thread.sleep()导致的线程可见的情况

TODO

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,189评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,577评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,857评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,703评论 1赞 276
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,705评论 5赞 366
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,620评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,995评论 3赞 396
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,656评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,898评论 1赞 298
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,639评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,720评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,395评论 4赞 319
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,982评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,953评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,195评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 44,907评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,472评论 2赞 342

推荐阅读更多精彩内容