多线程是java编程的重要部分，下面记录下synchronized和volatile关键字以及锁的问题。
传统单线程编程比较简单，一个程序从头走到尾，中间发生各种变量计算等，不会有意外发生。
而当有多线程在运行时，就会出现问题。
我们通过以下的代码来进行说明多线程运行不确定问题：
package app.test;
public class VolatileTest {
public static Boolean stop = false;
public static int i = 0;
public static void interrupt() {
stop = false;
while (!stop) {
System.out.println(i);
i++;
}
}
public static void main(String[] args) {
//线程1
new Thread(new Runnable() {
@Override
public void run() {
interrupt();
}
}).start();
//线程2
new Thread(new Runnable() {
@Override
public void run() {
stop = true;
}
}).start();
}
}
以上代码的运行结果是不确定的（可能不打印任何数字，可能打印到任意数字停止，还有可能一直打印递增数字至无限循环），即线程2中的stop赋值可能发生于线程1中函数的任意语句之前。
接下来记录下几个关键字的用法
一. volatile关键字
它是一个修饰成员变量的关键字。它只能保证可见性，不能保证原子性
JVM允许线程将变量的值从主存中拷贝一份到本线程的局部变量中，即线程拷贝变量后就不再与主存交互，直接与自己存储的副本交互，直到将更改后的值写回主存。而可见性保证线程可以让volatile修饰的变量不再相信自己的线程拷贝值，每次直接从主存中获取新值，保证用到的都是主存中的值。但请注意，这并不代表它保证永远用的是我们逻辑上期望的最新值。什么意思呢？
来看以下代码：
package app.test;
public class VolatileTest {
volatile int a = 1;
volatile int b = 2;
public void change(){
a = 3;
b = a;
}
public void print(){
System.out.println("b="+b+";a="+a);
}
public static void main(String[] args) {
while (true){
final VolatileTest test = new VolatileTest();
//线程1
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
test.change();
}
}).start();
//线程2
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
test.print();
}
}).start();
}
}
}
此例中，开启两个线程1和2，一个线程更改ab的值，一个线程打印ab的值，并且是无限循环地创建这一对线程，故运行此例会看到内存消耗不断增加。a和b两个变量由于加了volatile修饰，所以每一次a和b的值改变都会被打印出来，故其只有两种结果:
b=3;a=3
或
b=2;a=1
如下图：
这就是有volatile的效果，倘若不加volatile，那么还会多出一种结果：
b=3;a=1
如下图：
不加volatile为什么会出现这种情况呢？
在不断循环更改的情况下，可能会出现一种情况，某一次的线程对中的线程1将a修改为3后并没有立即写入主存中，即对a的修改对该线程对中的线程2是不可见的，所以线程2打印的a仍然是它线程中拷贝主存的值1，就出现了b=3;a=1这种情况。而volatile的作用就是让所修饰的变量对所有线程可见，即a只要值改变就会立即写入主存，其他线程再需要读取此变量时必须要去主存拿最新的值，不能用你线程栈自己拷贝的那份了，这就叫做实现了内存模型中变量的可见性。
但是，问题来了，如果多个线程对同一个变量进行了同时读取和修改，volatile无法保证操作的原子性。
举个栗子，家里支付宝一共有一万元存款，我和媳妇都可以使用，某一天我看上一个一万的电脑，她看上一个一万的包包，于是在一瞬间我们同时下单付款，这时支付系统就会有一个问题，支付宝需要先读取我的账户数看看够不够一万，然后它读取了之后发现刚好一万，还没来得及扣除的时候，另一个订单的支付也来读取我的账户，由于上一个订单还没有扣除一万元，所以这个订单读出来的也是一万，可以支付。最终结果就是二者都扣了一万，我的账户余额扣为零。一万当了两万用，美滋滋。
显然这是不可能的。
二. Synchronized关键字
既然volatile只能保证可见性，无法实现原子操作，那么同一个变量，两个线程都可以操作（读与写），如何保证其能够得到正确的结果呢？
问题就出在对我的余额这个变量有两个线程可以同时操作，没有加任何的锁去控制它。解决方案也很简单，就是让同一时刻只有一个线程去执行你需要加锁的同步代码，等这个线程执行完了，才释放锁允许另一个线程执行。
比如最常见的i++操作的原子性保证：
package app.test;
public class ThreadTest {
//number 此处没必要用volatile修饰
public static int number = 0;
//用 synchronized加锁保证同步
synchronized public static void inc() {
number++;
}
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
new Thread(new Runnable(){
@Override
public void run() {
inc();
}
}).start();
}
//循环等待，直到上面创建的1000个线程全部执行完毕，只剩一个主线程
while(Thread.activeCount() > 1)
Thread.yield();
System.out.println(number);
}
}
这是一段创建1000个线程来实现number++的程序，如果我们不对inc方法进行加锁控制，即使number有volatile修饰，最终结果也有可能是小于1000，因为number++不是原子操作，volatile无法保证。但，我们对inc方法加上synchronized之后，number++方法在同一时刻就只能有一个线程在执行，就保证了操作的原子性，最终结果必定是1000.
与此同时，保证同步除了synchronized之外还可以用lock手动加锁与释放锁，比如将上面的inc方法改为：
//用 lock加锁保证同步
public static void inc() throws InterruptedException {
Lock lock = new ReentrantLock();
lock.lock();
try {
number++;
} finally {
lock.unlock();
}
}
一样可以保证结果为1000.
以上就是多线程几个概念的粗略解释，关于锁还有很多内容后续再进行整理。
如有错误，敬请指正～
