JAVA面试题 简谈你对synchronized关键字的理解
面试官：sychronized关键字有哪些特性？
应聘者：
- 可以用来修饰方法;
- 可以用来修饰代码块;
- 可以用来修饰静态方法;
- 可以保证线程安全;
- 支持锁的重入;
- sychronized使用不当导致死锁;
了解sychronized之前,我们先来看一下几个常见的概念:内置锁、互斥锁、对象锁和类锁。
内置锁
在Java中每一个对象都可以作为同步的锁，那么这些锁就被称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
互斥锁
内置锁同时也是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B抛出异常或者正常执行完毕释放这个锁；如果B线程不释放这个锁，那么A线程将永远等待下去。
对象锁和类锁
对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的。
- 对象锁是用于对象实例方法；
- 类锁是用于类的静态方法或者一个类的class对象上的
一个对象无论有多少个同步方法区，它们共用一把锁，某一时刻某个线程已经进入到某个synchronzed方法，那么在该方法没有执行完毕前，其他线程无法访问该对象的任何synchronzied方法的，但可以访问非synchronzied方法。
如果synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在对象的对应的Class对象，
因为java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的static，synchronized方法时，他们的执行也是按顺序来的，也就是说一个线程先执行，一个线程后执行。
synchronized的用法：修饰方法和修饰代码块，下面分别分析这两种用法在对象锁和类锁上的效果。
对象锁的synchronized修饰方法和代码块
publicclassTestSynchronized{
publicvoidtest1(){
synchronized(this){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
}
publicsynchronizedvoidtest2(){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
publicstaticvoidmain(String[]args){
finalTestSynchronizedmyt2=newTestSynchronized();
Threadtest1=newThread(newRunnable(){
publicvoidrun(){
myt2.test1();
}
},"test1");
Threadtest2=newThread(newRunnable(){
publicvoidrun(){
myt2.test2();
}
},"test2");
test1.start();
test2.start();
}
}
打印结果如下：
test2:4 test2:3 test2:2 test2:1 test2:0 test1:4 test1:3 test1:2 test1:1 test1:0
上述的代码，第一个方法用了同步代码块的方式进行同步，传入的对象实例是this，表明是当前对象；第二个方法是修饰方法的方式进行同步
。因为第一个同步代码块传入的this，所以两个同步代码所需要获得的对象锁都是同一个对象锁，下面main方法时分别开启两个线程，分别调用test1和test2方法，那么两个线程都需要获得该对象锁，另一个线程必须等待。
上面也给出了运行的结果可以看到：直到test2线程执行完毕，释放掉锁，test1线程才开始执行。这里test2方法先抢到CPU资源，故它先执行，它获得了锁，它执行完毕后，test1才开始执行。
如果我们把test2方法的synchronized关键字去掉，执行结果会如何呢？
test1:4 test2:4 test2:3 test2:2 test2:1 test2:0 test1:3 test1:2 test1:1 test1:0
我们可以看到，结果输出是交替着进行输出的，这是因为，某个线程得到了对象锁，但是另一个线程还是可以访问没有进行同步的方法或者代码。进行了同步的方法（加锁方法）和没有进行同步的方法（普通方法）是互不影响的，一个线程进入了同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）。
类锁的修饰（静态）方法和代码块
publicclassTestSynchronized{
publicvoidtest1(){
synchronized(TestSynchronized.class){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
}
publicstaticsynchronizedvoidtest2(){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
publicstaticvoidmain(String[]args){
finalTestSynchronizedmyt2=newTestSynchronized();
Threadtest1=newThread(newRunnable(){
publicvoidrun(){
myt2.test1();
}
},"test1");
Threadtest2=newThread(newRunnable(){
publicvoidrun(){
TestSynchronized.test2();
}
},"test2");
test1.start();
test2.start();
}
}
输出结果如下：
test1:4 test1:3 test1:2 test1:1 test1:0 test2:4 test2:3 test2:2 test2:1 test2:0
类锁修饰方法和代码块的效果和对象锁是一样的，因为类锁只是一个抽象出来的概念，只是为了区别静态方法的特点，因为静态方法是所有对象实例共用的，所以对应着synchronized修饰的静态方法的锁也是唯一的，所以抽象出来个类锁。其实这里的重点在下面这块代码，synchronized同时修饰静态和非静态方法
publicclassTestSynchronized{
publicsynchronizedvoidtest1(){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
publicstaticsynchronizedvoidtest2(){
inti=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":"+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptionie){
}
}
}
publicstaticvoidmain(String[]args){
finalTestSynchronizedmyt2=newTestSynchronized();
Threadtest1=newThread(newRunnable(){
publicvoidrun(){
myt2.test1();
}
},"test1");
Threadtest2=newThread(newRunnable(){
publicvoidrun(){
TestSynchronized.test2();
}
},"test2");
test1.start();
test2.start();
}
}
输出结果如下：
test1:4 test2:4 test1:3 test2:3 test2:2 test1:2 test2:1 test1:1 test1:0 test2:0
上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。
synchronized是如何保证线程安全的
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，演示线程的安全问题：
我们来模拟一下火车站卖票过程，总共有100张票，总共有三个窗口卖票。
publicclassSellTicket{
publicstaticvoidmain(String[]args){
//创建票对象
Ticketticket=newTicket();
//创建3个窗口
Threadt1=newThread(ticket,"窗口1");
Threadt2=newThread(ticket,"窗口2");
Threadt3=newThread(ticket,"窗口3");
t1.start();
t2.start();
t3.start();
}
}
//模拟票
classTicketimplementsRunnable{
//共100票
intticket=100;
@Override
publicvoidrun(){
//模拟卖票
while(true){
if(ticket>0){
//模拟选坐的操作
try{
Thread.sleep(1);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖票:"
+ticket--);
}
}
}
}
运行结果发现：上面程序出现了问题
- 票出现了重复的票
- 错误的票0、-1
其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
那么出现了上述问题，我们应该如何解决呢？
线程同步（线程安全处理Synchronized）
java中提供了线程同步机制，它能够解决上述的线程安全问题。
线程同步的方式有两种：
- 方式1：同步代码块
- 方式2：同步方法
同步代码块
同步代码块:在代码块声明上加上synchronized
synchronized(锁对象){
可能会产生线程安全问题的代码
}
同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
使用同步代码块，对火车站卖票案例中Ticket类进行如下代码修改：
publicclassSellTicket{
publicstaticvoidmain(String[]args){
//创建票对象
Ticketticket=newTicket();
//创建3个窗口
Threadt1=newThread(ticket,"窗口1");
Threadt2=newThread(ticket,"窗口2");
Threadt3=newThread(ticket,"窗口3");
t1.start();
t2.start();
t3.start();
}
}
//模拟票
classTicketimplementsRunnable{
//共100票
intticket=100;
Objectlock=newObject();
@Override
publicvoidrun(){
//模拟卖票
while(true){
//同步代码块
synchronized(lock){
if(ticket>0){
//模拟选坐的操作
try{
Thread.sleep(1);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"正在卖票:"+ticket--);
}
}
}
}
}
当使用了同步代码块后，上述的线程的安全问题，解决了。
同步方法
同步方法：在方法声明上加上synchronized
publicsynchronizedvoidmethod(){
可能会产生线程安全问题的代码
}
同步方法中的锁对象是this
使用同步方法，对火车站卖票案例中Ticket类进行如下代码修改：
publicclassSellTicket{
publicstaticvoidmain(String[]args){
//创建票对象
Ticketticket=newTicket();
//创建3个窗口
Threadt1=newThread(ticket,"窗口1");
Threadt2=newThread(ticket,"窗口2");
Threadt3=newThread(ticket,"窗口3");
t1.start();
t2.start();
t3.start();
}
}
//模拟票
classTicketimplementsRunnable{
//共100票
intticket=100;
Objectlock=newObject();
@Override
publicvoidrun(){
//模拟卖票
while(true){
//同步方法
method();
}
}
//同步方法,锁对象this
publicsynchronizedvoidmethod(){
if(ticket>0){
//模拟选坐的操作
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖票:"
+ticket--);
}
}
}
synchronized支持锁的重入吗？
我们先来看下面一段代码：
publicclassReentrantLockDemo{
publicsynchronizedvoida(){
System.out.println("a");
b();
}
privatesynchronizedvoidb(){
System.out.println("b");
}
publicstaticvoidmain(String[]args){
newThread(newRunnable(){
@Override
publicvoidrun(){
ReentrantLockDemod=newReentrantLockDemo();
d.a();
}
}).start();
}
}
上述的代码，我们分析一下，两个方法，方法a和方法b都被synchronized关键字修饰，锁对象是当前对象实例，按照上文我们对synchronized的了解，如果调用方法a,在方法a还没有执行完之前，我们是不能执行方法b的，方法a必须先释放锁，方法b才能执行，方法b处于等待状态，那样不就形成死锁了吗？那么事实真的如分析一致吗？
运行结果发现：
a b
代码很快就执行完了，实验结果与分析不一致，这就引入了另外一个概念：重入锁。在java内部，同一线程在调用自己类中其他synchronized方法/块或调用父类的synchronized方法/块都不会阻碍该线程的执行。就是说同一线程对同一个对象锁是可重入的，而且同一个线程可以获取同一把锁多次，也就是可以多次重入。在JDK1.5后对synchronized关键字做了相关优化。
synchronized死锁问题
同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。
synchronzied(A锁){
synchronized(B锁){
}
}
我们进行下死锁情况的代码演示：
publicclassDeadLock{
Objectobj1=newObject();
Objectobj2=newObject();
publicvoida(){
synchronized(obj1){
synchronized(obj2){
System.out.println("a");
}
}
}
publicvoidb(){
synchronized(obj2){
synchronized(obj1){
System.out.println("b");
}
}
}
publicstaticvoidmain(String[]args){
DeadLockd=newDeadLock();
newThread(newRunnable(){
@Override
publicvoidrun(){
d.a();
}
}).start();
newThread(newRunnable(){
@Override
publicvoidrun(){
d.b();
}
}).start();
}
}
上述的代码，我们分析一下，两个方法，我们假设两个线程T1,T2，T1运行到方法a了，拿到了obj1这把锁，此时T2运行到方法b了，拿到了obj2这把锁，T1要往下执行，就必须等待T2释放了obj2这把锁，线程T2要往下面执行，就必须等待T1释放了持有的obj1这把锁，他们两个互相等待，就形成了死锁。
为了演示的更明白，需要让两个方法执行过程中睡眠10ms，要不然很难看到现象，因为计算机执行速度贼快
publicclassDeadLock{
Objectobj1=newObject();
Objectobj2=newObject();
publicvoida(){
synchronized(obj1){
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
synchronized(obj2){
System.out.println("a");
}
}
}
publicvoidb(){
synchronized(obj2){
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
synchronized(obj1){
System.out.println("b");
}
}
}
publicstaticvoidmain(String[]args){
DeadLockd=newDeadLock();
newThread(newRunnable(){
@Override
publicvoidrun(){
d.a();
}
}).start();
newThread(newRunnable(){
@Override
publicvoidrun(){
d.b();
}
}).start();
}
}
感兴趣的童鞋，下去可以试一下，程序执行不完，永远处于等待状态。
总结
- sychronized是隐式锁，是JVM底层支持的关键字，由JVM来维护；
- 单体应用下，多线程并发操作时，使用sychronized关键字可以保证线程安全;
- sychronized可以用来修饰方法和代码块，此时锁是当前对象实例，修饰静态方法时，锁是对象的class字节码文件;
- 一个线程进入了sychronized修饰的同步方法，得到了对象锁，其他线程还是可以访问那些没有同步的方法（普通方法）;
- sychronized支持锁的重入;
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。