Java并发之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(){...}}