透视Java多线程之三：一文搞定synchronized

1.什么是多线程同步

当多个线程同时共享同一个全局变量或者静态变量，做写操作时，可能会存在数据冲突的问题，也就是线程安全的问题。如果是读操作是不会发生数据冲突问题的。在《公路遇袭》故事中，没有明显有数据冲突的情节，但是在现实中却非常常见，比如春节抢票，假如从北京到上海就1辆车，1万张票，买票的人有10万，如果依次执行，第一个登陆进去的人看到余票1万，就买了，后面的人看到的余票只有9999张，然后顺序购买。假如一万个人同时在时刻0.0登陆，然后0.2秒后同时将票抢走，而在0.1秒的时候又有1万个人抢票，此时看到的余票仍然是1万张，然后在0.3s的时候下单，但是此时却没有票了，这时候系统就出现线程安全问题了。
我们现在模拟一下上述情况，并研究一下如何改进。首先我们假定有100张火车票，2个窗口同时抢票。
很容易写出如下代码：

class ThreadTrain implements Runnable {
    private int count = 100;

    @Override
    public void run() {
        while (count > 0) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sale();
        }
    }

    public void sale() {
        System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
        count--;

    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        ThreadTrain threadTrain = new ThreadTrain();
        Thread t1 = new Thread(threadTrain);
        Thread t2 = new Thread(threadTrain);

        t1.start();
        t2.start();
    }
}

但是此时打印结果是这样的：

Thread-1,出售第1票
Thread-0,出售第1票
Thread-0,出售第3票
Thread-1,出售第3票
Thread-0,出售第5票
Thread-1,出售第5票
Thread-0,出售第7票
Thread-1,出售第7票
Thread-0,出售第9票
Thread-1,出售第9票
········
Thread-0,出售第96票
Thread-1,出售第97票
Thread-0,出售第98票
Thread-1,出售第99票
Thread-0,出售第100票
Thread-1,出售第101票

很明显两个窗口将每个票都买了一遍，这就意味着同一个座位对应两张票，而且最后竟然还多卖了一张，这是不行的。
多卖了是因为剩下最后一张的时候，前一个线程判断count>0后正在睡眠期间后一个线程进来了，此时前者还没有卖出后者就继续执行了。对于上面的代码，我们首先想到卖出的时候先判断一下count是否大于0.

   public void sale() {
        if (count > 0) {
            System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
            count--;
        }
    }

执行来看，最后没有多卖出，就避免了上面遇到的问题，但是仍然存在重复卖票的情况。如何解决呢？多线程之间使用同步synochronized或者使用锁lock。

2.多线程的三大特征

上面我们通过一个例子说明了什么是多线程同步，如何通过严谨的计算机语言来描述呢？
多线程程序具备三大特征：原子性，可见性和有序性。
什么是原子性
即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
一个很经典的例子就是银行账户转账问题：
比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。
我们操作数据也是如此，比如i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在Java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步和lock这些东西来确保这个特性了。
原子性其实就是保证数据一致、线程安全一部分，
什么是可见性
当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。
什么是有序性
程序执行的顺序按照代码的先后顺序执行。
一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。如下：
int a = 10; //语句1
int r = 2; //语句2
a = a + 3; //语句3
r = a*a; //语句4
则因为重排序，他还可能执行顺序为 2-1-3-4，1-3-2-4
但绝不可能 2-1-4-3，因为这打破了依赖关系。
显然重排序对单线程运行是不会有任何问题，而多线程就不一定了，所以我们在多线程编程时就得考虑这个问题了。

3.synochronized解决访问冲突

synochronized可以对某个代码块包起来，也可以将某个函数加上synochronized来修饰，前者称为同步代码块，后者称为同步函数。
使用同步函数解决访问冲突问题的方法是将可能发生冲突的代码用synochronized包起来，结构如下

  synchronized (同一个数据){
            可能发生线程冲突问题的代码
        }

这里的同一个数据是什么呢？可以是任意对象，我测试过，使用静态变量可以，使用System.getenv()可以，在sale里定义一个局部变量也可以，使用Integer a=1;也可以，总之是个对象就可以。不过为了防止费解，我们还是使用全局变量或者静态变量比较好一些。所以我们完整的代码如下所示：

class ThreadTrain implements Runnable {
    private int count = 100;
    private static Object o1 = new Object();

    @Override
    public void run() {
        while (count > 0) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sale();
        }
    }

    public void sale() {
        Integer a=1;
        synchronized (a) {
            if (count > 0) {
                System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
                count--;
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        ThreadTrain threadTrain = new ThreadTrain();
        Thread t1 = new Thread(threadTrain);
        Thread t2 = new Thread(threadTrain);

        t1.start();
        t2.start();
    }
}

同步函数写法比较简单，主要在函数前加上synchronized就可以了。也就是如下所示：

   public synchronized void sale() {
        if (count > 0) {
            System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
            count--;
        }
    }

同步函数使用的什么锁？

同步函数将什么锁起来保证线程同步呢？使用的是this锁。我们可以做一个测试，将this锁起来，看看线程执行情况，代码如下：

class ThreadTrain2 implements Runnable {
    private int count = 100;
    public boolean flag = true;
    private static Object oj = new Object();

    @Override
    public void run() {
        if (flag) {

            while (count > 0) {

                synchronized (this) {
                    if (count > 0) {
                        try {
                            Thread.sleep(50);
                        } catch (Exception e) {
                        }
                        System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
                        count--;
                    }
                }

            }

        } else {
            while (count > 0) {
                sale();
            }
        }

    }

    public synchronized void sale() {
        // 前提 多线程进行使用、多个线程只能拿到一把锁。
        // 保证只能让一个线程 在执行 缺点效率降低
        // synchronized (oj) {
        if (count > 0) {
            try {
                Thread.sleep(50);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
            count--;
        }
        // }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) throws InterruptedException {
        ThreadTrain2 threadTrain1 = new ThreadTrain2();
        Thread t1 = new Thread(threadTrain1, "1号窗口");
        Thread t2 = new Thread(threadTrain1, "2号窗口");
        t1.start();
        Thread.sleep(40);
        threadTrain1.flag = false;
        t2.start();
    }
}

这里在run方法中，将this，也就是当前对象直接锁起来了，此时其他线程执行sale时一直拿不到锁，所以我们看到的情况是都是窗口1获得票，窗口2永远没有被执行。
如果我们将sale前的synchronize去掉，或者将run方法中synchronized (this) 中的this换掉，就可正常同步了。

在上面的例子中，如果在sale前加上static将其变成静态同步函数，此时会怎么样呢？
我们知道static变量或者成员函数是属于类的，而不是对象的，所以此时同步函数锁的是该函数所属字节码文件对象，可以使用getClass()方法获取，也可以用当前类名.class表示。完整代码：

class ThreadTrain2 implements Runnable {
    private static int count = 100;
    public boolean flag = true;
    private static Object oj = new Object();

    @Override
    public void run() {
        if (flag) {
            while (count > 0) {
            //这里也可以用ThreadTrain2.getClass()
                synchronized (ThreadTrain2.class) {
                    if (count > 0) {
                        try {
                            Thread.sleep(50);
                        } catch (Exception e) {
                        }
                        System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
                        count--;
                    }
                }

            }

        } else {
            while (count > 0) {
                sale();
            }
        }

    }

    public static synchronized void sale() {
        // synchronized (oj) {
        if (count > 0) {
            try {
                Thread.sleep(50);
            } catch (Exception e) {
            }
            System.out.println(Thread.currentThread().getName() + ",出售第" + (100 - count + 1) + "票");
            count--;
        }
        // }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) throws InterruptedException {
        ThreadTrain2 threadTrain1 = new ThreadTrain2();
        Thread t1 = new Thread(threadTrain1, "1号窗口");
        Thread t2 = new Thread(threadTrain1, "2号窗口");
        t1.start();
        Thread.sleep(40);
        threadTrain1.flag = false;
        t2.start();
    }
}

4.Volatile关键字

Volatile关键字的作用是变量在多个线程间可见。看一个例子：

class ThreadVolatileDemo extends Thread {
    public  boolean flag = true;

    @Override
    public void run() {
        System.out.println("开始执行子线程....");
        while (flag) {
        }
        System.out.println("线程停止");
    }

    public void setRuning(boolean flag) {
        this.flag = flag;
    }

}


public class ThreadVolatile {
    public static void main(String[] args) throws InterruptedException {
        ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo();
        threadVolatileDemo.start();
        Thread.sleep(3000);
        threadVolatileDemo.setRuning(false);
        System.out.println("flag 已经设置成false");
        Thread.sleep(1000);
        System.out.println(threadVolatileDemo.flag);

    }

}

在这里已经将结果设置为false了，为什么还会一直运行呢？原因是线程之间是不可见的，读取的是副本，没有及时读取到主内存结果，也就是说第一个threadVolatileDemo.start();执行的时候就将的这里的false在启动的时候就将flag设置为true一直在执行了，后面主线程设置threadVolatileDemo.setRuning(false);时，子线程就没有接收到flag的变化。
这时候就需要使用volatile关键字解决线程之间的可见行，强制子线程每次读取该值的时候都去“主内存”中取值。

volatile可以保证线程之间可见性，但是不能保证原子性。看一个例子：

public class VolatileNoAtomic extends Thread {
    private volatile static int count = 0;

    private void addCount() {
        //System.out.printf(getName() + " init count:" + count + "    ");
        for (int i = 0; i < 1000; i++) {
            count++;
        }
        System.out.println("count:" + count);
    }

    public void run() {
        addCount();
    }

    public static void main(String[] args) {

        VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        /**/
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }
}

程序预期的结果是每个线程拿到一个count的累加初始值，然后依次加1000次，并输出结果。如果执行你会发现，所有的count 初始值都是0，而结果则不一定有10000。这是因为volatile仅仅保证各个线程都能读到,而在执行count++的时候，不能保证所有的操作都是原子的。解决方法是将count定义为原子类，也就是：

public class VolatileNoAtomic extends Thread {
//    private volatile static int count = 0;
    private static AtomicInteger count = new AtomicInteger(0);

    private void addCount() {
    //    System.out.printf(getName() + " init count:" + count + "    ");
        for (int i = 0; i < 1000; i++) {
//            count++;
            count.incrementAndGet();
        }
        System.out.println("count:" + count);
    }

    public void run() {
        addCount();
    }

    public static void main(String[] args) {

        VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        /**/
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }
}

这时候打印的结果就一定会有一个输出为10000

4.ThreadLocal关键字

该关键字的作用是为使用该变量的每个线程提供一个独立的副本，所以每个线程可以独立地改变自己的副本，而不影响其他线程对应的副本。
ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：
• void set(Object value)设置当前线程的线程局部变量的值。
• public Object get()该方法返回当前线程所对应的线程局部变量。
• public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
• protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。例子：创建三个线程，每个线程生成自己独立的序列号。

class Res {
    // 生成序列号共享变量
    public static Integer count = 0;
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        protected Integer initialValue() {
            return 0;
        }

    };

    public Integer getNum() {
        int count = threadLocal.get() + 1;
        threadLocal.set(count);
        return count;
    }
}

public class ThreadLocaDemo2 extends Thread {
    private Res res;

    public ThreadLocaDemo2(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + "i---" + i + "--num:" + res.getNum());
        }
    }

    public static void main(String[] args) {
        Res res = new Res();
        ThreadLocaDemo2 threadLocaDemo1 = new ThreadLocaDemo2(res);
        ThreadLocaDemo2 threadLocaDemo2 = new ThreadLocaDemo2(res);
        ThreadLocaDemo2 threadLocaDemo3 = new ThreadLocaDemo2(res);
        threadLocaDemo1.start();
        threadLocaDemo2.start();
        threadLocaDemo3.start();
    }
}