java synchronized关键字浅析

synchronized这个关键字想必学Java的人都应该知道。

直接上例子:

方法级别实例

public class AtomicInteger {

    private int index;

    public synchronized int addAndGet() {
        try {
            Thread.sleep(2000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return ++ index;
    }

    public int get() {
        return index;
    }

}

一个自动增长的类,不解释了。

看测试代码:

final AtomicInteger ai = new AtomicInteger();

new Thread(new Runnable() {
    @Override
    public void run() {
        ai.addAndGet();
        System.out.println("thread1 finish sleep");
    }
}).start();

new Thread(new Runnable() {
    @Override
    public void run() {
        ai.addAndGet();
        System.out.println("thread2 finish sleep");
    }
}).start();

 

这里例子执行结果是这样的:

过2秒,输出thread1 finish sleep

然后再过2秒,输出thread2 finish sleep。

 

现在我们把AtomicInteger类里的addAndGet方法前的synchronized关键字去掉。

执行结果是这样的:

过2秒,输出  thread1 finish sleep  然后马上输出  thread2 finish sleep (可能先输出thread2 finish sleep)

分析

java中synchronized就是"加锁"的意思, 一个实例中的方法如果加上了synchronized,那么这个方法如果被调用了,就会自动加上一个锁,如果其他线程想要再次调用这个实例的这个方法,那么需要等待之前的线程执行完成之后才能执行。

因此,之前的实例方法之前有synchronized的执行结果就是过2秒输出一段,再过2秒再次输出。

类级别实例

 下面。 我们给AtomicInteger加一个静态同步方法。

public static synchronized void sync() {
    System.out.println("now synchronized. wait 4 seconds.");
    try {
        Thread.sleep(2000l);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

测试代码:

final AtomicInteger ai = new AtomicInteger();

AtomicInteger.sync();

new Thread(new Runnable() {
    @Override
    public void run() {
        ai.addAndGet();
        System.out.println("thread1 finish sleep");
    }
}).start();

new Thread(new Runnable() {
    @Override
    public void run() {
        ai.addAndGet();
        System.out.println("thread2 finish sleep");
    }
}).start();

这个测试结果执行结果是这样的:

先输出  now synchronized. wait 4 seconds.

过4秒(因为静态同步方法需要2秒,addAndGet方法也需要2秒),输出 thread1 finish sleep  

再过2秒,输出 thread2 finish sleep

分析

从上述类级别的实例可以看出  ->   静态同步方法作用的范围是类,执行了静态同步方法,静态同步方法执行的时候,这个类中的所有方法(无论是否有synchronized, 无论是否静态)都必须等待这个静态同步方法执行完成之后才能进行

如果我们把AtomicInteger的addAndGet方法的synchronized关键字去掉,那么执行结果是这样的。

先输出  now synchronized. wait 4 seconds.

过4秒,输出 thread1 finish sleep  

然后马上又输出 thread2 finish sleep

 

再来看个例子:

final AtomicInteger ai1 = new AtomicInteger();
final AtomicInteger ai2 = new AtomicInteger();

AtomicInteger.sync();

new Thread(new Runnable() {
    @Override
    public void run() {
        ai1.addAndGet();
        System.out.println("ai1 finish sleep");
    }
}).start();

new Thread(new Runnable() {
    @Override
    public void run() {
        ai2.addAndGet();
        System.out.println("ai2 finish sleep");
    }
}).start();

执行结果是这样的。

先输出  now synchronized. wait 4 seconds.

过4秒,输出 ai1 finish sleep  

然后马上又输出 ai2 finish sleep

 

小结: 由于静态同步方法是作用于类级别的,因此实例级别的方法调用都收到影响。所以执行AtomicInteger.sync();的时候ai1,ai2都在等待。 当执行完毕的时候,ai1和ai2由于是不同实例,方法级别的synchronized当然互不影响。

资源级别的实例

资源级别的同步其实跟方法级别的同步是一样的,只不过资源级别的同步的作用更加细节一下,它作用的对象是基于资源的。比如实例中的成员变量。

死锁,可以完美说明资源级别的同步。

public class DeadLock {

    private static Object obj1 = new Object();
    private static Object obj2 = new Object();

    public static void main(String[] args) {
        new Thread(new SubThread1()).start();
        new Thread(new SubThread2()).start();
    }

    private static class SubThread1 implements Runnable {
        @Override
        public void run() {
            synchronized (obj1) {
                try {
                    Thread.sleep(1000l);
                    System.out.println("thread1 synchronized obj1 and wait for obj2.");
                    synchronized (obj2) {
                        System.out.println("thread1 synchronized obj2");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class SubThread2 implements Runnable {
        @Override
        public void run() {
            synchronized (obj2) {
                try {
                    Thread.sleep(1000l);
                    System.out.println("thread2 synchronized obj2 and wait for obj1.");
                    synchronized (obj1) {
                        System.out.println("thread2 synchronized obj1");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

从死锁这个实例可以看出。

子线程1同步obj1资源的时候,其他线程是不能获得obj1这个资源的。同理,子线程同步obj2资源的时候,其他线程是不能获得obj2这个资源的。

因此,子线程1在同步obj1之后,会等待obj2的释放(obj2已经被子线程2同步了,子线程1不能获得);而子线程2在同步obj2之后,会等待obj1的释放(obj1已经被子线程1同步了,子线程2不能获得)。

所以,这个程序将永远地等待下去。 这也就是著名的死锁问题。

我们可以通过jdk提供的一些命令查看是否死锁。

首先通过jps查看当前jdk启动的进程。

找到死锁这个程序的进程号6552之后再通过  jstack -l 6552 查看堆栈信息。

看到jstack发现了一个死锁。

总结

synchronized关键字可以作用在多个场景之下,我们需要区分清楚各个场景的区别,以便我们设计出符合高并发的程序。

之前对java并发这块了解的太少了.. 面试的时候也问到这些问题,发现自己根本答不上来。

posted on 2014-03-21 13:41  format丶  阅读(1038)  评论(5编辑  收藏  举报

导航