JAVA入门学习笔记（二）

多线程是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的效果，倘若不加volatile，那么还会多出一种结果：

b=3;a=1

如下图：

无volatile修饰结果

不加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.

以上就是多线程几个概念的粗略解释，关于锁还有很多内容后续再进行整理。

如有错误，敬请指正～