java synchronized关键字_java synchronized关键字浅析

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

直接上例子：

方法级别实例

public classAtomicInteger {private intindex;public synchronized intaddAndGet() {try{

Thread.sleep(2000l);

}catch(InterruptedException e) {

e.printStackTrace();

}return ++index;

}public intget() {returnindex;

}

}

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

看测试代码：

final AtomicInteger ai = newAtomicInteger();new Thread(newRunnable() {

@Overridepublic voidrun() {

ai.addAndGet();

System.out.println("thread1 finish sleep");

}

}).start();new Thread(newRunnable() {

@Overridepublic voidrun() {

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 voidsync() {

System.out.println("now synchronized. wait 4 seconds.");try{

Thread.sleep(2000l);

}catch(InterruptedException e) {

e.printStackTrace();

}

}

测试代码：

final AtomicInteger ai = newAtomicInteger();

AtomicInteger.sync();new Thread(newRunnable() {

@Overridepublic voidrun() {

ai.addAndGet();

System.out.println("thread1 finish sleep");

}

}).start();new Thread(newRunnable() {

@Overridepublic voidrun() {

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 = newAtomicInteger();final AtomicInteger ai2 = newAtomicInteger();

AtomicInteger.sync();new Thread(newRunnable() {

@Overridepublic voidrun() {

ai1.addAndGet();

System.out.println("ai1 finish sleep");

}

}).start();new Thread(newRunnable() {

@Overridepublic voidrun() {

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 classDeadLock {private static Object obj1 = newObject();private static Object obj2 = newObject();public static voidmain(String[] args) {new Thread(newSubThread1()).start();new Thread(newSubThread2()).start();

}private static class SubThread1 implementsRunnable {

@Overridepublic voidrun() {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 implementsRunnable {

@Overridepublic voidrun() {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并发这块了解的太少了.. 面试的时候也问到这些问题，发现自己根本答不上来。