Synchronized锁的是什么?

Synchronized的是什么?

临界区与锁

并发编程中不可避免的会出现多个线程共享同一个资源的情况,为了防止出现数据不一致情况的发生,人们引入了临界区的概念。临界区是一个用来访问共享资源的代码块,同一时间内只运行一个线程进入。

那么如何实现这个临界区呢?这就用到我们的锁了,当进程想要访问一个临界区时,它先会去看看是否已经有其他线程进入了,也就是看是否能获得锁。如果没有其他线程进入,那么它就进入临界区,其他线程就无法进入,相当于加锁。反之,则会被挂起,处于等待状态,直到其他线程离开临界区,且本线程被JVM选中才可进入(因为可能有其他线程也在等待)。

利用Synchronized解决并发问题

Synchronize是一个重量级锁,它会降低程序性能,因此如果对数据一致性没有要求,就不要使用它。如果方法被Synchronize关键字声明,那么该方法的代码块被视为临界区。当某个线程调用该对象的synchronized方法或者访问synchronized代码块时,这个线程便获得了该对象的锁,其他线程暂时无法访问这个方法,只有等待这个方法执行完毕或者代码块执行完毕,这个线程才会释放该对象的锁,其他线程才能执行这个方法或者代码块。

下面我们将创建两个线程A,B来同时访问一个对象:A从账户里取钱,B从账户里存钱。首先是不使用Synchronized关键字。

创建账户类

它拥有一个私有变量balance表示金额,addAmount和subtractAmount分别对金额执行加减操作。

public class Account {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public void addAmount(double amount){
        System.out.println("addAmount start");
        double temp=balance;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        temp+=amount;
        balance=temp;
        System.out.println("addAmount end");
    }

    public void subtractAmount(double amount){
        System.out.println("subtractAmount start");
        double temp=balance;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        temp-=amount;
        balance=temp;
        System.out.println("subtractAmount end");
    }
}

创建A,B俩线程,分别对账户存钱和取钱。

public class A implements Runnable {
    private Account account;
    public A(Account account){
        this.account=account;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            account.addAmount(1000);
        }
    }
}
public class B implements Runnable  {
    private Account account;
    public B(Account account){
        this.account=account;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            account.subtractAmount(1000);
        }
    }
}

最后在main里面测试

public class Main {
    public static void main(String[] args) {
        Account account=new Account();
        account.setBalance(1000);
        A a=new A(account);
        Thread ThreadA=new Thread(a);
        B b=new B(account);
        Thread ThreadB=new Thread(b);
        System.out.println("Account Balance:"+account.getBalance());
        ThreadA.start();
        ThreadB.start();
        try {
            ThreadA.join();
            ThreadB.join();
            System.out.println("Account Balance:"+account.getBalance());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ThreadA往账户中执行了10次存入操作,每次存入1000元,ThreadB则是以同样的金额执行了10次取出操作。那么按照我们的推测,最后账户的金额应该维持不变,但程序的结果却不是我们想要的数字。这是为什么呢?因为我们在对数据进行操作的时候,另外一个线程可能也在进行操作,逻辑上应该先后执行的方法变成了同时执行,所以出现了错误。

现在我们给addAmount和subtractAmount加上synchronized关键字,保证数据一致性,这样程序就不会出问题了。

如果是使用synchronize保护代码块,则需要将对象引用作为参数传入。一般来说传入this关键字作为引用执行方法的对象就可以了。

锁的到底是什么?

或许在上面的例子你因为粗心只为其中一个方法加了关键字,那么你会看到这样的现象:

Synchronized锁的是什么?

保护代码块要将对象传入,那应该锁的是对象呀。你可能会想:我执行subtractAmout,按道理应该等我执行完addAmount才能执行,它都没有account这个对象的锁,不应该在中间插这么一段呀。但是,只有加了锁的方法,线程执行该方法时才会去尝试获得锁,看看是否有线程进入临界区。访问非同步方法无需获得锁,你把synchronized去掉跟你只加一个的情况是一样的,同步方法与非同步遵循的是不同的规则。也就是说你可以在调用该对象的加了synchronized方法的同时,调用其他的非同步方法。

两个线程怎么同时访问了同一个对象的两个synchronized方法?

你可能在捣鼓这个关键字的时候,惊讶的发现静态方法的与众不同。如果一个对象中的静态方法用synchronized修饰,那么其他线程可以在该静态方法被访问的同时,访问该对象中的非静态方法(当然,该静态方法同一时间只能被一个线程访问)。换句话说,两个线程可以同时访问一个对象中的两个synchronized方法。

等等,不是说锁对象吗?到底锁的是什么?锁的确实是对象,但对于静态方法我们说的是T.class(T 为类名),非静态方法锁的是this ,也就是类的实例对象,两者是不同的。

class T {
  // 修饰非静态方法
  public synchronized void a() {
    // 临界区
  }
  // 修饰静态方法
  public synchronized static void b() {
    // 临界区
  }
}

上面那段代码相当于:

class T {
  // 修饰非静态方法
  public synchronized(this) void a() {
    // 临界区
  }
  // 修饰静态方法
  public synchronized(T.class) static void b() {
    // 临界区
  }
}

实际上加锁本质就是在锁对象的对象头中写入当前线程id。我们可以通过下面的代码验证,每次都传入new Object()。

class Account {
    private double balance;
    public synchronized void addAmount(double amount){
        synchronized (new Object()){
            System.out.println("addAmount start");
            double temp=balance;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            temp+=amount;
            balance=temp;
            System.out.println("addAmount end");
        }
    }
    public void subtractAmount(double amount){
    	synchronized (new Object()){
            System.out.println("subtractAmount start");
            double temp=balance;
            try {
                Thread.sleep(100); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            temp-=amount;
            balance=temp;
            System.out.println("subtractAmount end");
        }
    }
}

因为线程每次调用方法锁的都是新new的对象,所以加锁无效。甚至编译器可能会将synchronized给优化掉,因为这相当于多把锁保护同一个资源,编译器一看,每个人都弄把锁就进来了,那我还不如不加,反正都一个样。

另外需要注意的是,synchronized是可重入锁。也就是说当线程访问对象的同步方法时,在调用其他同步方法时无需再去获取其访问权。因为我们实际上锁的是对象,对象头里面纪录的都是当前线程的ID。

总结

  • 修饰函数,锁的是当前类的实例化对象
  • 修饰静态方法,锁的是当前类的Class对象
  • 修饰同步代码块,锁的是括号里的对象

加锁实际上就是在锁对象的对象头中写入当前线程id,每个线程要想调用这个同步方法,都会先去锁对象的对象头看看当前线程id是不是自己的。

参考

​ synchronized锁定的到底是什么?-知乎

原文 

http://www.cnblogs.com/AD-milk/p/13253972.html

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Synchronized锁的是什么?

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址