Java 锁机制 synchronized

概述

春节的时候去面试了一家公司,笔试题里面有一道是使用简单的代码实现线程的‘死锁’,当时没有想到这道题考的是Synchronized关键字,于是自己定义了两个资源模拟了一下。后面想想肠子都悔青了,于是自己在电脑上敲了一遍,同时也是对自己的一个提醒,基础功夫还不够扎实。

同步关键字用于在多个线程中需要对同一段数据进行访问时候,出现的不安全情况。因为多个线程执行同一段代码会造成数据不安全,所以需要用synchronized来同步代码。

转载请标明出处:
本文出自【赵彦军的博客】

Synchronized关键字

Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。

  1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
  2. 然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
  3. 尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
  4. 第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
  5. 以上规则对其它对象锁同样适用.

修饰一个类
其作用的范围是synchronized后面括号括起来的部分,作用的对象是这个类的所有对象,只要是这个类型的class不管有几个对象都会起作用。如下代码

1、前言

澳门新葡萄京官网注册,在多线程并发编程中Synchronized一直是元老级角色,很多人都会称呼它为重量级锁,但是随着Java
SE1.6对Synchronized进行了各种优化之后,有些情况下它并不那么重了,本文详细介绍了Java
SE1.6中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁,以及锁的存储结构和升级过程。

代码示例

package test160118;

public class TestSynchronized {
    public static void main(String[] args) {
        Sy sy = new Sy(0);
        Sy sy2 = new Sy(1);
        sy.start();
        sy2.start();
    }
}

class Sy extends Thread {
    private int flag ;

    static Object x1 = new Object();
    static Object x2 = new Object();

    public Sy(int flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        System.out.println(flag);
        try {
            if (flag == 0) {
                synchronized (x1) {
                    System.out.println(flag+"锁住了x1");
                    Thread.sleep(1000);
                    synchronized (x2) {
                        System.out.println(flag+"锁住了x2");
                    }
                    System.out.println(flag+"释放了x1和x2");
                }
            }
            if(flag == 1) {
                synchronized (x2) {
                    System.out.println(flag+"锁住了x2");
                    Thread.sleep(1000);
                    synchronized (x1) {
                        System.out.println(flag+"锁住了x1");
                    }
                    System.out.println(flag+"释放了x1和x2");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class ClassName {
    public void method() {
       synchronized(ClassName.class) {
          // todo
       }
    }
 }

2、同步的基础

java中的每一个对象都可以作为锁。

对于同步方法,锁是当前实例对象。
对于静态同步方法,锁是当前对象的Class对象。
对于同步方法块,锁是Synchonized括号里配置的对象。
当一个线程试图访问同步代码块时,它首先必须得到锁,退出或抛出异常时必须释放锁。那么锁存在哪里呢?锁里面会存储什么信息呢?

总结

总之说多了都是泪,关键不是我不会而是我没有想到它考的都是这个。也不知道面试过没过,有点方。后面会陆陆续续把之前面试时答得不是很好的几道题写成专栏的。

修饰一个方法
synchronized 修饰一个方法很简单,就是在方法的前面加synchronized,例如:

3、同步的原理

JVM规范规定JVM基于进入和退出Monitor对象来实现方法同步和代码块同步,但两者的实现细节不一样。代码块同步是使用monitorenter和monitorexit指令实现,而方法同步是使用另外一种方式实现的,细节在JVM规范里并没有详细说明,但是方法的同步同样可以使用这两个指令来实现。monitorenter指令是在编译后插入到同步代码块的开始位置,而monitorexit是插入到方法结束处和异常处,
JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个
monitor 与之关联,当且一个monitor 被持有后,它将处于锁定状态。线程执行到
monitorenter 指令时,将会尝试获取对象所对应的 monitor
的所有权,即尝试获得对象的锁。

public synchronized void method()
{
   // todo
}

4、synchronized 关键字

java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。

一:当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二:然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三:尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

在定义接口方法时不能使用synchronized关键字。
构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。
synchronized 关键字不能被继承 ,如果要同步需要显式的加上关键字。
synchronized
关键字修饰的方法如果被重写默认不同步,如果要同步需要显式的加上关键字,或者super父类的方法也就相当于同步了。

5、类锁和对象锁

java的对象锁和类锁:java的对象锁和类锁在锁的概念上基本上和内置锁是一致的,但是,两个锁实际是有很大的区别的。
对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态方法或者一个类的class对象上的。我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所以不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

  • 类锁和对象锁

package com;

public class Person {
    static Person person ;

    /**
     * 类锁
     */
    public void run1(){
        synchronized( Person.class ) {
            System.out.println( Thread.currentThread().getName()  + "  11-->  " + "a" );
        }
    }

    /**
     * 类锁
     * 
     * 静态方法锁,是类锁
     */
    public synchronized static void run11(){

    }

    /**
     *  类锁
     */
    public static void run(){

        synchronized ( Person.class ) {

        }
    }

    /**
     * 对象锁
     */
    public void run2(){
        synchronized( this ) {
            System.out.println( Thread.currentThread().getName()  + "  22-->  " + "a" );
        }
    }

    /**
     * 对象锁
     * 普通方法锁是对象锁
     */
    public synchronized void run3(){
        System.out.println( Thread.currentThread().getName()  + "  33-->  " + "a" );
    }




}

其实,类锁修饰方法和代码块的效果和对象锁是一样的,因为类锁只是一个抽象出来的概念,只是为了区别静态方法的特点,因为静态方法是所有对象实例共用的,所以对应着synchronized修饰的静态方法的锁也是唯一的,所以抽象出来个类锁。类锁和对象锁是两个不一样的锁,控制着不同的区域,它们是互不干扰的。同样,线程获得对象锁的同时,也可以获得该类锁,即同时获得两个锁,这是允许的。

这时有一个疑问,既然有了synchronized修饰方法的同步方式,为什么还需要synchronized修饰同步代码块的方式呢?而这个问题也是synchronized的缺陷所在。

synchronized的缺陷:当某个线程进入同步方法获得对象锁,那么其他线程访问这里对象的同步方法时,必须等待或者阻塞,这对高并发的系统是致命的,这很容易导致系统的崩溃。如果某个线程在同步方法里面发生了死循环,那么它就永远不会释放这个对象锁,那么其他线程就要永远的等待。这是一个致命的问题。

当然同步方法和同步代码块都会有这样的缺陷,只要用了synchronized关键字就会有这样的风险和缺陷。既然避免不了这种缺陷,那么就应该将风险降到最低。这也是同步代码块在某种情况下要优于同步方法的方面。

例如在某个类的方法里面:这个类里面声明了一个对象实例,SynObject so=new
SynObject();在某个方法里面调用了这个实例的方法so.testsy();但是调用这个方法需要进行同步,不能同时有多个线程同时执行调用这个方法。

这时如果直接用synchronized修饰调用了so.testsy();代码的方法,那么当某个线程进入了这个方法之后,这个对象其他同步方法都不能给其他线程访问了。假如这个方法需要执行的时间很长,那么其他线程会一直阻塞,影响到系统的性能。

如果这时用synchronized来修饰代码块:synchronized(so){so.testsy();},那么这个方法加锁的对象是so这个对象,跟执行这行代码的对象没有关系,当一个线程执行这个方法时,这对其他同步方法时没有影响的,因为他们持有的锁都完全不一样。

一个类的对象锁和另一个类的对象锁是没有关联的,当一个线程获得A类的对象锁时,它同时也可以获得B类的对象锁。


个人微信号:zhaoyanjun125 , 欢迎关注

澳门新葡萄京官网注册 1

修饰代码块

public  void method()
{
   synchronized(this)
   synchronized(XX.class)
}

synchronized(this)锁的是当前对象,当前有几个对象那么这个this就是有多份,这里的this只能锁同一个对象。
synchronized(XX.class)只要是这个类型的class这把锁就都有用

当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
以上规则对其它对象锁同样适用.

修饰静态方法
我们知道 静态方法是属于类的而不属于对象的 。同样的,
synchronized修饰的静态方法锁定的是这个类的所有对象,所有类用它都会有锁的效果。

public synchronized static void method() {
   // todo
}

总结:

A.
无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。
B.
每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。
C.
实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。
D.同步关键字锁的是对象

参考

发表评论

电子邮件地址不会被公开。 必填项已用*标注