并发一些基本的概念
共享、可变、线程安全性、线程同步、原子性、可见性、有序性
共享内存
每个线程表示一条单独的执行流，有自己的程序计数器，有自己的栈，但线程之间可以共享内存，它们可以访问和操作相同的对象。代码如下：
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，显式锁都可以保证有序性。
