在java多线程编程中，我们经常会遇见这样的一种情况，在我们输入相同的数据，有时候输出的数据是正确，有时候输出的结果却是错误的，这种计算结果的正确性与时间有关的现象就被称之为竞态。

1.竞态产生的原因

   在多线程编程时会出现多个线程共同访问一个变量，这样的变量即我们所说的共享变量或者共享资源；竞态产生的条件之一就是在于多个线程同时访问相同的变量并进行读写操作，当其中一个线程需要根据某个变量的状态来相应执行某个操作的之前，该变量很可能已经被其它线程修改，这个时候就产生的竞态。下边我们看个例子

public class Statistics {
    private int count = 0;
    private void add(int i){
        count = count + i;
        System.out.println("线程"+Thread.currentThread().getId()+":"+count);
    }

    public static  class StatisticsRunnable implements Runnable{
        private  Statistics statistics;
        public StatisticsRunnable( Statistics statistics){
            this.statistics = statistics;
        }
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                this.statistics.add(1);
            }
        }
    }

    public static void main(String[] args) {
        Statistics statistics = new Statistics();
        Thread t1 = new Thread(new StatisticsRunnable(statistics));
        Thread t2 = new Thread(new StatisticsRunnable(statistics));
        t1.start();
        t2.start();
    }
}

运行结果：

线程12:2
线程11:2
线程12:3
线程11:4
线程12:5
线程11:6
线程12:7
线程11:8
线程11:10
线程12:9
线程11:11
线程12:12
线程11:13
线程12:14
线程11:15
线程12:16
线程11:17
线程12:18
线程11:19
线程12:20

   按照常规逻辑，我们的统计类一直在增量加1，每个线程所打印的count是不会一样的，但是结果确并不是这样，出现了有时候结果是我们所想的，有时候却出现了两个线程打印相同的结果。这就是我所谓的竞态了，导致竞态的常见因素是多个线程在没有采取任何控制措施的情况下并发的更新、读取同一个共享变量。我反过来看例子，在线程11加完1之后，准备打印count,这个时候线程12并发的更新了count,导致线程实际打印的是线程12已经加1之后的count，出现了和想象不一样的结果，当我们加大循环次数，再多次运行上面的例子，我们还能发现最终的统计结果和我们想象有一定的差距，这种情况是两个线程交错的更新count,会出现一个线程的结果重新覆盖已经加1的count,这样就少统计了。所以竞态往往伴随着读取脏数据的问题，即一个线程读取到一个过时的数据，丢失更新问题，即一个线程所做的更新没有体现在后续其他线程对该数据的读取上。
   需要注意的竞态不一定就导致计算结果的不正确，它只是不排除计算结果有时候正确，有时候错误，这也是我们多线程编程需要非常注意的，可能我们自测时并发量小，出现的结果都是正确的，一旦到线上高并发的情况时就出现了错误的结果，所以当多线程编程时如果出现共享变量一定需要注意是否会出现竞态。

2.竞态的模式

   在竞态的典型案例中，常常有两个竞态模式：read-modify-write(读-改-写)和check-then-act(检测后行动)。read-modify-write(读-改-写)这个操作分为这几个步骤：一个线程读取了一个共享变量的值，然后根据这个值做一下计算，最后在更新该共享变量的值，在这个操作中如果我们没有采取任何控制措施，那么就可能出现竞态；一起分析一下这个过程，我们在读取一个值后，刚准备用这个值，但是这个时候这个值被别的线程改变了，同样的我们计算出结果需要更新这个结果，但是这个时候出现直接覆盖了别的线程更新过的值，这个过程出现了“脏读”和“更新丢失”的问题。check-then-act(检测后行动)这个操作的步骤：读取某个共享变量的值，根据该变量的值决定下一步的动作是什么时，在这个过程中，我们决定下一步准备怎么做的时候可能这个共享变量的值被别的线程更新了，出现了下一步的操作就不是我们想要的操作了，这样也出现了竞态。多线程编程中可以套用这两种模式，在使用一个共享变量时是否会出现以上两种模式的情况，就可以分析出是否会出现竞态。

2.竞态的解决方法

   竞态的产生往往是操作共享变量产生的，所以当多个线程需要操作共享资源的时候，它们需要以某种顺序来确保该共享变量在某一时刻只能被一个线程使用，也就是说，当线程A需要使用共享变量，如果该共享变量正被线程B使用，同步机制就会让线程A一直等待下去，直到线程B结束对该共享变量的使用，线程A才能使用。比如我们在add的方法上加上synchronized 关键字之后在运行则结果一直正确的。 synchronized关键字会使其修改的方法在任时刻只能被一个线程执行，该方法涉及的共享变量在任意时刻只能有一个线程访问（读，写），从而避免了这个方法交错执行的而导致的干扰，这样就消除了竞态。

public class Statistics {
    private int count = 0;
    private synchronized void add(int i){
        count = count + i;
        System.out.println("线程"+Thread.currentThread().getId()+":"+count);
    }

    public static  class StatisticsRunnable implements Runnable{
        private  Statistics statistics;
        public StatisticsRunnable( Statistics statistics){
            this.statistics = statistics;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                this.statistics.add(1);
            }
        }
    }

    public static void main(String[] args) {
        Statistics statistics = new Statistics();
        Thread t1 = new Thread(new StatisticsRunnable(statistics));
        Thread t2 = new Thread(new StatisticsRunnable(statistics));
        t1.start();
        t2.start();
    }
}

还有一种解决竞态的方法在多个线程访问共享变量时对共享变量的操作加锁，使共享变量在任意时刻只能有一个线程访问（读，写），也就避免了这个方法交错执行的而导致的干扰。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Statistics {
    private Lock lock = new ReentrantLock();
    private int count = 0;
    private synchronized void add(int i){
        try{
            lock.lock();
            count = count + i;
            System.out.println("线程"+Thread.currentThread().getId()+":"+count);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public static  class StatisticsRunnable implements Runnable{
        private  Statistics statistics;
        public StatisticsRunnable( Statistics statistics){
            this.statistics = statistics;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                this.statistics.add(1);
            }
        }
    }

    public static void main(String[] args) {
        Statistics statistics = new Statistics();
        Thread t1 = new Thread(new StatisticsRunnable(statistics));
        Thread t2 = new Thread(new StatisticsRunnable(statistics));
        t1.start();
        t2.start();
    }
}

当然锁是一种重量级的操作，我们使用锁需要注意很过地方，这个些在接下来的文章中我都会讲到了，从这个两个例子我们可以看出避免竞态的实质就是，使共享变量在任意时刻只能有一个线程访问（读，写），满足我们上一篇文章的多线编程的原子性、可见性、有序性，就可以很好的避免竞态了