线程并发问题

背景

所有的并发问题，不外资源争抢。资源可以是一个变量，也可以是一条数据库资源，广义上的资源也可以是某一些列的操作。
资源争抢不一定会出现异常，出现异常必须要满足一个条件：即非原子操作。

分析

假如是原子操作，那么及时发生了资源并发争抢，原子操作内部状态还是一致的。
假如非原子操作，那么就可能会发生异常（不一定100%重现），即相当于读脏数据。处于操作的之间的资源就会被其他线程可见，此时其他线程会直接读取脏数据进行操作，从而发生了并发问题。

CASE

一个很简单的例子，两个线程同时开始对同一个变量（资源竞争的前提）进行计数，其中计数的操作就是i++（资源竞争的条件，非原子操作）。即在A线程执行i++的时候，由于i++非原子操作，内部状态可见。可以把i++拆分为以下操作

(1)取出i，i=100
(2)i = i+1,i=101
(3)存储i，i=101

假如在A线程执行第一步的时候，B线程也执行第一步，这个时候，执行完毕的时候，总次数就少加了一次。

package HSFTEST.test;

import org.junit.Test;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by jianghuiwen on 17/8/17.
 */
public class TestAuto {

    @Test
    public void test() throws InterruptedException {
        Count count = new Count();
        new Thread(new Client(count)).start();
        new Thread(new Client(count)).start();

        Thread.sleep(Integer.MAX_VALUE);
    }

    class Count{
        private Long num = 0L;
        public void add(){
            num = num + 1;
        }

        public Long getNum(){
            return num;
        }
    }

    public void func(AtomicInteger atomicInteger){
        atomicInteger.decrementAndGet();
        System.out.println(atomicInteger.get());
    }

    class Client implements Runnable{
        private Count count;
        public Client(Count count){
            this.count = count;
        }
        @Override
        public void run() {

            for(int i=0;i<10000;i++){
                count.add();
            }

            System.out.println(count.getNum());
        }
    }
}

solution

对于所有竞争的解决方式，最适用的办法，就是加锁。对竞争资源进行加锁，使得不会出现非原子操作。
对于class和变量来说，一般使用java内部提供的锁或者原子变量即可完成。
对于其他资源，例如数据库记录等，则需要使用加第三方锁来完成，即在资源被一方占用时，就加锁防止其他线程进入，直至上个操作执行完成。

package HSFTEST.test;

import org.junit.Test;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by jianghuiwen on 17/8/17.
 */
public class TestAuto2 {

    @Test
    public void test() throws InterruptedException {
        Count count = new Count();
        new Thread(new Client(count)).start();
        new Thread(new Client(count)).start();

        Thread.sleep(Integer.MAX_VALUE);
    }

    class Count{
        private AtomicInteger atomicInteger  = new AtomicInteger(0);
        public void add(){
            atomicInteger.incrementAndGet();
        }

        public int getNum(){
            return atomicInteger.get();
        }
    }

    public void func(AtomicInteger atomicInteger){
        atomicInteger.decrementAndGet();
        System.out.println(atomicInteger.get());
    }

    class Client implements Runnable{
        private Count count;
        public Client(Count count){
            this.count = count;
        }
        @Override
        public void run() {

            for(int i=0;i<10000;i++){
                count.add();
            }

            System.out.println(count.getNum());
        }
    }
}