并发一些基本的概念

共享、可变、线程安全性、线程同步、原子性、可见性、有序性

共享内存

每个线程表示一条单独的执行流，有自己的程序计数器，有自己的栈，但线程之间可以共享内存，它们可以访问和操作相同的对象。代码如下：

public class ShareMemoryDemo {
    //共享变量
    private static int shared = 0;
    private static void incrShared(){
        shared ++;
    }
    static class ChildThread extends Thread {
        List<String> list;
        public ChildThread(List<String> list) {
            this.list = list;
        }
        @Override
        public void run() {
            incrShared();
            list.add(Thread.currentThread().getName());
        }
    }  
  public static void main(String[] args) throws InterruptedException{
        List<String> list = new ArrayList<String>();
        Thread t1 = new ChildThread(list);
        Thread t2 = new ChildThread(list);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(shared);
        System.out.println(list);
    }
}

在代码中，定义了一个静态变量shared和静态内部类ChildThread，在main方法中，创建并启动了两个ChildThread对象，传递了相同的list对象，ChildThread的run方法访问了共享的变量shared和list，main方法最后输出了共享的shared和list的值，大部分情况下，会输出期望的值：

2
[Thread-0, Thread-1]

通过这个例子，我们想强调说明执行流、内存和程序代码之间的关系。

• 该例中有三条执行流，一条执行main方法，另外两条执行ChildThread的run方法。
• 不同执行流可以访问和操作相同的变量，如本例中的shared和list变量。
• 不同执行流可以执行相同的程序代码，如本例中incrShared方法，ChildThread的run方法，被两条ChildThread执行流执行，incrShared方法是在外部定义的，但被ChildThread的执行流执行，在分析代码执行过程时，理解代码在被哪个线程执行是很重要的。
• 当多条执行流执行相同的程序代码时，每条执行流都有单独的栈，方法中的参数和局部变量都有自己的一份。
  当然出现共享的时候就会出现竞态，也就是线程的安全问题

竟态条件和线程安全

线程安全是一个比较复杂的概念。其核心概念就是正确性。所谓正确性就是某各类的行为与其规范完全一致，即其近似与“所见即所知（we know it when we see it）”。当多个线程访问某各类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。（引自：《Java并发编程实战》）
竞态条件
所谓竞态条件(race condition)是指，当多个线程访问和操作同一个对象时，最终执行结果与执行时序有关，可能正确也可能不正确，我们看一个例子：

public class CounterThread extends Thread {
    private static int counter = 0;
    @Override
    public void run() {
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            // 讲道理捕获的内容必须有所处理。
        }
        counter ++;
    }
public static void main(String[] args) throws InterruptedException{
        int num = 1000;
        Thread[] threads = new Thread[num];
        for(int i=0; i<num; i++){
            threads[i] = new CounterThread();
            threads[i].start();
        }
        for(int i=0; i<num; i++){
            threads[i].join();
        }
        System.out.println(counter);
    }
}

这段代码容易理解，有一个共享静态变量counter，初始值为0，在main方法中创建了1000个线程，每个线程就是随机睡一会，然后对counter加1，main线程等待所有线程结束后输出counter的值。
期望的结果是1000，但实际执行，发现每次输出的结果都不一样，一般都不是1000，经常是900多。为什么会这样呢？因为counter++这个操作不是原子操作，它分为三个步骤：

1.取counter的当前值
2.在当前值基础上加1
3.将新值重新赋值给counter

两个线程可能同时执行第一步，取到了相同的counter值，比如都取到了100，第一个线程执行完后counter变为101，而第二个线程执行完后还是101，最终的结果就与期望不符。
怎么解决这个问题呢？有多种方法：

• 使用synchronized关键字
• 使用显式锁
• 使用原子变量
  由于内容比较多会另外一篇文章详解研究。

内存可见性

多个线程可以共享访问和操作相同的变量，但一个线程对一个共享变量的修改，另一个线程不一定马上就能看到，甚至永远也看不到，这可能有悖直觉，来看一个例子。

public class VisibilityDemo {
    private static boolean shutdown = false;
    static class HelloThread extends Thread {
        @Override
        public void run() {
            while(!shutdown){
                // do nothing
            }
            System.out.println("exit hello");
        }
    }
    public static void main(String[] args) throws InterruptedException{
        new HelloThread().start();
        Thread.sleep(1000);
        shutdown = true;
        System.out.println("exit main");
    }
}

在这个程序中，有一个共享的boolean变量shutdown，初始为false，HelloThread在shutdown不为true的情况下一直死循环，当shutdown为true时退出并输出"exit hello"，main线程启动HelloThread后睡了一会，然后设置shutdown为true，最后输出"exit main"。

期望的结果是两个线程都退出，但实际执行，很可能会发现HelloThread永远都不会退出，也就是说，在HelloThread执行流看来，shutdown永远为false，即使main线程已经更改为了true。

这是怎么回事呢？这就是内存可见性问题。在计算机系统中，除了内存，数据还会被缓存在CPU的寄存器以及各级缓存中，当访问一个变量时，可能直接从寄存器或CPU缓存中获取，而不一定到内存中去取，当修改一个变量时，也可能是先写到缓存中，而稍后才会同步更新到内存中。在单线程的程序中，这一般不是个问题，但在多线程的程序中，尤其是在有多CPU的情况下，这就是个严重的问题。一个线程对内存的修改，另一个线程看不到，一是修改没有及时同步到内存，二是另一个线程根本就没从内存读。

怎么解决这个问题呢？有多种方法：

使用volatile关键字
使用synchronized关键字或显式锁同步

关于这些方法，另外开章节来研究。

原子性

原子是世界上最小的单位，具有不可分割性(当然这个理论早就被推翻了，原子下面还有质子和中子、中子后面..)。在我们编程的世界里，某个操作如果不可分割我们就称之为该操作具有原子性。例如：i = 0,这个操作是不可分割的，所以该操作具有原子性。如果某个操作可以分割，那么该操作就不具备原子性，例如i++。非原子操作都存在线程安全问题，这个时候我们需要使用同步机制来保证这些操作变成原子操作，来确保线程安全。

有序性

有序性指的是数据不相关的变量在并发的情况下，实际执行的结果和单线程的执行结果是一样的，不会因为重排序的问题导致结果不可预知。volatile, final, synchronized，显式锁都可以保证有序性。