Java并发之synchronized关键字

     上篇文章我们主要介绍了并发的基本思想以及线程的基本知识，通过多线程我们可以实现对计算机资源的充分利用，但是在最后我们也说明了多线程给程序带来的两种典型的问题，针对它们，synchronized关键字可以很好的解决问题。对于synchronized的介绍主要包含以下一些内容：

• synchronized修饰实例方法
• synchronized修饰静态方法
• synchronized修饰代码块
• 使用synchronized解决竞态条件问题
• 使用synchronized解决内存可见性问题

一、使用synchronized关键字修饰实例方法

     在我们的Java中，每个对象都有一把锁和两个队列，一个用于挂起未获得锁的线程，一个用于挂起条件不满足而不得不等待的线程。而我们的synchronized实际上也就是一个加锁和释放锁的集成。先看个例子：

/*定义一个计数器类*/
public class Counter {
    private int count;

    public synchronized int getCount(){return this.count;}

    public synchronized void addCount(){this.count++;}
}

/*定义一个线程类*/
public class MyThread extends Thread{

    public static Counter counter = new Counter();

    @Override
    public void run(){
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        counter.addCount();
    }
}

/*main方法启动100个线程*/
public static void main(String[] args){
        Thread[] threads = new Thread[100];
        for (int i=0;i<100;i++){
            threads[i] = new MyThread();
            threads[i].start();
        }

        for (int j=0;j<100;j++){
            threads[j].join();
        }

        System.out.println(MyThread.counter.getCount());
    }

上述程序无论运行多少次，结果都是一样的。

这是一个典型的使用synchronized关键字修饰实例方法来解决竞态条件问题的示例。首先在我们定义的线程类中，我们定义了一个Counter实例，然后让以后的每个线程在运行的时候都先随机睡眠，然后调用这个公共变量count的自增方法，只不过该自增方法是有synchronized关键字修饰的。我们说过每个对象都有锁和两个队列，这里的count实例就是一个对象，这一百个线程每次在睡醒之后都要调用count的addCount方法，而所有要调用addCount方法的线程都必须先获得count这个对象的锁，也就是说，如果有一个线程获取了count对象的锁并开始调用addCount方法时，其他线程都得阻塞在该对象的一个队列上，等待获得锁的线程执行结束释放锁。

所以，在同一时刻，只可能有一个线程获得count的锁并对其进行自增操作，其他的线程都在该对象的阻塞队列上进行等待，自然是不会出现多个线程在某个时间段同时操作同一个变量而引起该变量数据值不正确的情况。

二、使用synchronized关键字修饰静态方法

     对于静态方法，其实和实例方法是类似的。只不过synchronized关键字对实例方法而言，它获得的是实例对象的锁，所有共享相同该对象的线程都必须先获得该对象的锁。而对于静态方法而言，synchronized关键字获得的是类的锁，也就是对于所有需要访问相同类的线程都是需要先获得该类的锁的，否则将需要在某个阻塞队列上进行等待。

/*定义一个线程类*/
public class MyThread extends Thread{

    public static int count;

    public synchronized static void addCount(){
        count++;
    }
    @Override
    public void run(){
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        addCount();
    }
}

/*启动100个线程*/
public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[100];
        for (int i=0;i<100;i++){
            threads[i] = new MyThread();
            threads[i].start();
        }

        for (int j=0;j<100;j++){
            threads[j].join();
        }

        System.out.println(MyThread.count);
    }

程序基本和我们的第一个例子相差无几，在线程类中我们定义了一个静态变量和一个静态方法，该方法被synchronized关键字修饰，然后run方法依然是让当前线程随机睡眠，然后调用这个被synchronized关键字修饰的静态方法。我们可以看到，无论运行多少次的程序，结果都是一样。

每个线程在睡醒之后，都要去调用addCount方法，而调用该方法前提是要获取到类Count的锁，如果获取不到就必须在该对象的阻塞队列上进行等待。所以一次只会有一个线程调用addCount方法，自然是无论运行多少次，结果都会是100。

三、使用synchronized关键字修饰代码块

     使用synchronized关键字修饰一段代码块和上述介绍的两种情况略微有点不同。对于实例方法，synchronized关键字总是尝试去获取某个对象的锁，对于静态方法，synchronized关键字始终尝试去获取某个类的锁，而对于我们的代码块，它就需要显式指定以谁为锁了。例如：

/*定义一个线程类*/
public class MyThread extends Thread{

    public static Integer count = 0;

    @Override
    public void run(){
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (count){
            count++;
        }
    }
}

在我们定义的线程类中，我们定义了一个静态变量count，而每个线程在醒来之后都会去尝试着去获取该对象的锁，如果得不到就阻塞在该对象的阻塞队列上等待锁的释放。实际上这里的synchronized关键字利用的就是对象count的锁，我们上述介绍的两种形式，synchronized关键字修饰在实例方法和静态方法上，默认利用的是类对象的锁和类的锁。例如：

public synchronized void show(){....}

调用show方法等价于：

synchronized(this){
	public void show(){...}
}

而对于静态方法：

public class A{
	public synchronized static void show(){....}
}

等价于：

synchronized(A.class){
	public static void show(){....}
}

四、使用synchronized关键字解决内存可见性问题

     通过了解了synchronized应用的三种不同场景，我们对它应该有了大致的一个了解。下面我们使用它解决上篇提到的多线程的一个问题 ----- 内存可见性问题。至于竞态条件问题已经在第一小节间接的进行介绍了，此处不再赘述。这里我们再简单重复下内存可见性问题，因为我们的CPU是有缓存的，所以当一个线程在运行的时候，有些变量值的修改并没有立马写回内存，而是缓存在各级缓存中，这就导致其他线程访问这个公共变量的时候就拿不到最新的值，因此导致数据的值偏差，计算结果不准确。我们看看一个例子：

/*定义一个线程类，并定义一个共享的变量count*/
public class MyThread extends Thread{

    public static int count = 0;

    @Override
    public void run(){
        while (count==0){
            //running
        }
        System.out.println("mythread exit");
    }
}

/*main函数启动一个线程*/
public static void main(String[] args) throws InterruptedException {
        Thread thread = new MyThread();
        thread.start();

        Thread.sleep(1000);

        MyThread.count = 1;
        System.out.println(MyThread.count);
        System.out.println("exit main");

    }

我们在定义的线程类中定义了一个共享变量，run方法主要的工作是循环等待count不为0，而我们在main线程中修改了这个count的值，由于循环这个操作是比较频繁的判断条件的，所以该线程并不会每次都从内存中取出count的值，而是在它的缓存中取，所以主线程对count的修改，在thread线程中是始终看不见的。所以我们的程序输出的结果如下：

主线程在修改count的值之后，输出显示的确count的值为1，然后主线程退出，但是我们发现程序却没有结束，thread的退出信息也没有被打印。也就是说线程thread还被困在了while循环中，虽然main线程已经修改了count的值。这就是内存可见性问题，主要是由于多线程之间进行通讯的桥梁是内存，而各个线程内部又有各自的缓存，如果对公共变量的的修改没有及时更新到内存的话，那么就很容易导致其他线程访问的是数据不是最新的。

我们使用synchronized关键字解决上述问题：

public class MyThread extends Thread{

    public static int count = 0;

    public synchronized static int returnCount(){return count;}

    @Override
    public void run(){
        while(returnCount()==0){

        }
        System.out.println("mythread exit");
    }
}

我们使用synchronized关键修饰了一个方法，该方法返回count的值。jvm对synchronized的两条规定，其一是线程在解锁之前必须把所有共享变量刷新到内存中，其二是线程在释放锁的时候将清空所有的缓存迫使本线程在使用该共享变量的时候从内存中去读取。这样就可以保证每次对共享变量的读取都是最新的。

当然如果仅仅是为了解决内存可见性问题而使用synchronized关键字的话，会有点大材小用。毕竟synchronized的成本开销相对而言是较大的。Java中提供了一个volatile关键字用于解决这种内存可见性问题。例如：

public static volatile int count = 0;

像这样，我们只需要在某个变量前面加上修饰符 volatile 即可让该变量在被读的时候从内存去取，也就是保持最新数据值以实现对内存可见性问题的解决。

至此，我们简单的介绍了synchronized关键字的一些基本用法，介绍了它可以修饰的场景，以及使用它来解决我们的两个典型的多线程问题。下篇文章我们将着重介绍线程间的协作机制。