同步关键字Synchronized剖析

最新推荐文章于 2023-02-16 23:43:00 发布
最新推荐文章于 2023-02-16 23:43:00 发布
阅读量207 收藏
点赞数
分类专栏： JAVA语言基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinchunzhao123/article/details/109955906
版权

一、使用

Synchronized分为：对象锁、类锁

1.对象锁

（1）同步代码块锁

    

@Slf4j
public class Demo1 {
    public static void main(String[] args) throws Exception{
        Person person = new Person();
        new Thread(() -> {
            synchronized (person){
                try {
                    log.debug(Thread.currentThread().getName() +"线程执行了run方法");
                    Thread.sleep(2000L);
                    log.debug(Thread.currentThread().getName() +"线程执行完毕");
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (person){
                try {
                    log.debug(Thread.currentThread().getName() +"线程执行了run方法");
                    Thread.sleep(2000L);
                    log.debug(Thread.currentThread().getName() +"线程执行完毕");
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

总结：使用Synchronized锁住了run方法中的代码块，表示同一个时刻只能有一个线程能够进入代码块。两个线程锁定同一个对象，相当于两个线程只有一把锁，所以要依次执行。

 

同步代码块锁的是对象，假如让每个线程拥有不同的锁，去访问不同的方法资源呢？

@Slf4j
public class Demo1 {
    public static void main(String[] args) throws Exception{
        Person person1 = new Person();
        Person person2 = new Person();
        Thread thread1 = new Thread(() -> {
            synchronized (person1) {
                try {
                    log.debug(Thread.currentThread().getName() + "线程执行了run方法");
                    Thread.sleep(2000L);
                    log.debug(Thread.currentThread().getName() + "线程执行完毕");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (person2) {
                try {
                    log.debug(Thread.currentThread().getName() + "线程执行了run方法");
                    Thread.sleep(2000L);
                    log.debug(Thread.currentThread().getName() + "线程执行完毕");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()){}
        log.debug("主线程执行结束");
    }
}

 

总结：同步代码块锁只是对代码块进行加锁，同一时刻只能有一个线程获取锁，每一把锁只负责当前代码块。两个线程锁定不同的对象，相当于两把锁，各自执行各自的代码互不干扰。

 

（2）方法锁

@Slf4j
public class Demo1 {
    public static void main(String[] args) throws Exception{
        Demo1 demo1 = new Demo1();

        Thread thread1 = new Thread(() -> {
            demo1.getName();
        });

        Thread thread2 = new Thread(() -> {
            demo1.getName();
        });
        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()){}
        log.debug("主线程执行结束");
    }

    public synchronized void getName(){
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了getName方法");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

总结：两个线程对同一个普通同步方法访问，同一个时刻只能有一个线程进入该方法。

 

@Slf4j
public class Demo1 {
    public static void main(String[] args) throws Exception{
        Demo1 demo1 = new Demo1();

        Thread thread1 = new Thread(() -> {
            demo1.getName();
            demo1.getAge();
        });

        Thread thread2 = new Thread(() -> {
            demo1.getName();
            demo1.getAge();
        });
        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()){}
        log.debug("主线程执行结束");
    }

    public synchronized void getName(){
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了getName方法");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized void getAge(){
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了getAge方法");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行方法getAge完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

总结：Synchronized锁定的是对象，所以同一时刻两个方法中只能有一个线程在执行。

 

2.类锁

（1）static方法锁

@Slf4j
public class Demo1 implements Runnable{
    public static void main(String[] args) throws Exception{

        Demo1 demo1 = new Demo1();

        Demo1 demo2 = new Demo1();

        Thread thread1 = new Thread(demo1);

        Thread thread2 = new Thread(demo2);
        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()){}
        log.debug("主线程执行结束");
    }

    public static synchronized void getName(){
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了静态方法getName");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行静态方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override public void run() {
        getName();
    }
}

总结：定义了两个对象，但是类只有一个，所以同一个时刻只能有一个线程访问该方法。如果把static去掉，就是普通的同步方法，两个线程访问两个对象的方法，也就是每个线程拿到不同的锁，就能随便进入方法了。

（2）Class锁

@Slf4j
public class Demo1 implements Runnable{
    public static void main(String[] args) throws Exception{

        Demo1 demo1 = new Demo1();

        Demo1 demo2 = new Demo1();

        Thread thread1 = new Thread(demo1);

        Thread thread2 = new Thread(demo2);
        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()){}
        log.debug("主线程执行结束");
    }

    public void getName(){
        synchronized (Demo1.class) {
            try {
                log.debug(Thread.currentThread().getName() + "线程执行了方法getName");
                Thread.sleep(2000L);
                log.debug(Thread.currentThread().getName() + "线程执行方法getName完毕");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
    @Override
    public void run() {
        getName();
    }
}

这个例子Synchronized锁定的是类Demo1.class，而不是对象。发现线程1、线程2会依次执行。

 

总结：如果多个线程执行的是同一把锁，则依次执行，否则各种执行各自的，互不干扰。

 

三、6种常见情况

1.两个线程同时访问一个对象的同步方法

总结：同一时刻只能有一个方法访问成功。

2.两个线程访问两个对象的同步方法

总结：Synchronized包装普通同步方法，是对象锁。由于两个线程访问两个对象的同一个同步方法，也就是这个方法有两把锁，此时锁不起作用，线程1、线程2可以互不干扰的访问该方法。

 

 

3.两个线程访问synchronized的静态方法

 

@Slf4j 
public class Demo1  {

    public static void main(String[] args) throws Exception {
        Thread thread1 = new Thread(() -> {
            getName();
        });

        Thread thread2 = new Thread(() -> {
            getName();
        });

        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()) {
        }
        log.debug("主线程执行结束");
    }

    public synchronized static void getName() {
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了静态同步方法getName");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行静态同步方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

总结：两个线程访问同一个静态同步方法，发现此时是同一时刻只能有一个线程能够访问成功。

 

4.两个线程同时访问同步方法和非同步方法

@Slf4j
public class Demo1 implements Runnable{

    public static void main(String[] args) throws Exception {

        Demo1 demo1 = new Demo1();

        Thread thread1 = new Thread(demo1);

        Thread thread2 = new Thread(demo1);

        thread1.start();
        thread2.start();
        //thread1、thread2只要有一个还活着，则一直执行
        while (thread1.isAlive() || thread2.isAlive()) {
        }
        log.debug("主线程执行结束");
    }

    public synchronized  void getName() {
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了普通同步方法getName");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行普通同步方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public  void getAge() {
        log.debug(Thread.currentThread().getName() + "线程执行了普通方法getAge");
        log.debug(Thread.currentThread().getName() + "线程执行普通方法getAge完毕");
    }

    @Override
    public void run() {
        getName();
        getAge();
    }
}

总结：两个线程分别同时访问普通同步方法、普通方法。同一时刻普通同步方法只能有一个线程能够访问成功，普通方法不受影响。

 

5.一个线程访问一个类的两个普通同步方法

@Slf4j
public class Demo1 implements Runnable{

    public static void main(String[] args) throws Exception {

        Demo1 demo1 = new Demo1();

        Thread thread1 = new Thread(demo1);

        

        thread1.start();
        //thread1、只要还活着，则一直执行
        while (thread1.isAlive() ) {
        }
        log.debug("主线程执行结束");
    }

    public synchronized  void getName() {
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了普通同步方法getName");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行普通同步方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized void getAge() {
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了普通同步方法getAge");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行普通同步方法getAge完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        getName();
        getAge();
    }
}

总结：由于同步代码块锁的是当前对象，this。 而且也只new了一个对象。所以同一时刻只能有一个线程能够访问成功。其实当只有一个线程访问时，上不上锁都是一样的，这里可以认为锁是失效的。

6.同时访问静态同步方法和非静态同步方法

@Slf4j
public class Demo1 implements Runnable{

    public static void main(String[] args) throws Exception {

        Demo1 demo1 = new Demo1();

        Thread thread1 = new Thread(demo1);

        Thread thread2 = new Thread(demo1);

        thread1.start();
        thread2.start();
        //只要有一个线程还活着，则一直执行
        while (thread1.isAlive() ) {
        }
        log.debug("主线程执行结束");
    }

    public synchronized  void getName() {
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了普通同步方法getName");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行普通同步方法getName完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public synchronized static  void getAge() {
        try {
            log.debug(Thread.currentThread().getName() + "线程执行了静态同步方法getAge");
            Thread.sleep(2000L);
            log.debug(Thread.currentThread().getName() + "线程执行静态同步方法getAge完毕");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        getName();
        getAge();
    }
}

 

总结：由此可见，普通同步方法与静态同步方法没有任何关联。普通同步方法锁的是对象，静态同步方法锁的是类。

二、缺点：

1.可重入性

不同方法是可重入的

同一个方法是可重入的

不同类方法是可重入的

2.不可中断

一个线程拿到锁之后，其他线程只能等待当前线程执行完毕获取抛异常，释放锁，其他线程才能获取锁，中间不可被打断。如果当前线程一直占用该锁，其他线程就会处于一直等待状态中。

3.不够灵活

加锁、解锁，每个锁只能有一个对象处理，不适用于分布式场景。

4.无法知道是否成功获取锁

5、效率低

Synchronized是不可中断的，所以当一个等待的线程获取不到锁，就会一直等待，而不去做其他的事情。但是可以设置等待时间，超过等待时间又没有拿到锁，就不会继续等待而去做其他事情

 

 

Hi，all
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
synchronized关键字（同步锁）详细解析
IBLiplus的博客
10-08 1868
这里大部分的解释都在代码中。 demo1 package synchornizeds; public class Demo1 { private int count; private Object o = new Object(); public void m() { synchronized (o) { //任何线程执行一下代码都要申请o对应的锁。此处的o是堆内存中new...
【速看】一文清明讲明白线程同步关键字synchronized
最新发布
唐欢
03-27 476
synchronized 关键字是java的保留字，synchronized 关键字保障了原子性、可见性和有序性。 在java中，线程同步使用最多的方法是使用synchronized关键字，使用synchronized(synchObject)调用相当于获取synchObject的内置锁，对临界区代码段进行排他性保护。synchronized块是java提供的一种原子性内置锁，java中的每个对象都可以把它当做一个同步锁来使用，这些java内置的使用者看不到的锁被称为内部锁，也叫做监视器锁。
同步关键字synchronized的实现（2019-10-08）
dept123的专栏
10-09 389
首先了解常见的锁概念： 互斥锁/独占锁、共享锁 乐观锁、悲观锁 自旋锁、可重入锁、不可重入锁 轻量级锁、重量级锁、偏向锁。 现在回忆一下同步关键字synchronized的使用场景： 1.用于实例方法、静态方法时，隐式指定锁对象；实例方法隐式锁定this对象，静态方法隐式锁定当前类的class对象； 2.用于代码块时，显示指定锁对象。 其特性可以概括为：可重入、独占、悲观。 接下...
Synchronized 关键字原理
qxf865618770的博客
04-20 840
Synchronized关键字解决的是多个线程之间访问资源的同步性， synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。使用Java的小伙伴都知道synchronized关键字是解决并发问题常用解决方案，常用的有以下三种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码， 作用的...
Java关键字——synchronized
qq_35854212的博客
02-16 699
synchronized使用和原理全解
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
详细解读java同步之synchronized解析
08-26
Java中的`synchronized`关键字是实现多线程同步的重要机制，它确保了在并发环境中对共享资源的访问是线程安全的。以下是对`synchronized`的详细解读： ### 1. synchronized的特性 - **互斥性**：当一个线程进入一...
Java synchronized关键字和Lock接口实现原理
08-25
Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。 synchronized 关键字 synchronized 关键字...
JAVA面试题 简谈你对synchronized关键字的理解
08-25
Synchronized关键字是Java语言中的一种同步机制，主要用于解决多线程之间的同步问题。下面我们将详细介绍synchronized关键字的特性、用法和注意事项。 Synchronized关键字的特性 1. 可以用来修饰方法：...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
在Java编程语言中，synchronized关键字用于实现线程同步，以确保多线程环境下的数据一致性。它主要用于控制对共享资源的并发访问，防止多个线程同时进入临界区，可能导致数据不一致或竞态条件的问题。本文将深入探讨...
同步关键字 synchronized
11-15 98
synchronized：同步，如果当一个对象访问类里面的同步方法的话，那么其它的对象如果想要继续访问类里面的这个同步方法的话，就会进入阻塞，只有等前一个对象执行完该同步方法后当前对象　才能够继续执行该方法。这就是同步。 相反，如果方法前没有同步关键字修饰的话，那么不同的对象可以在同一时间访问同一个方法，这就是异步。 转载于:https://www.cnblogs.com/xfen...
HashMap的四种同步方式
时间慢慢的博客
09-06 7547
1、使用synchronized关键字 synchronized(anObject) { value = map.get(key); } //将获取方法锁住Map m = Collections.synchronizeMap(hashMap); 同步的方式与1相同，返回一个同步的map，这个map封装了HashMap中所有的方法；2、用lock lock.lock(); Va
关于synchronized关键字的认识
Yoryky的专栏
09-02 2649
很多时候在阅读Android源码时，都会碰到synchronized这个关键字，实际上我一直是知道这个方法的作用是让方法或者代码块的操作具有原子性，从而解决多线程共享资源的问题，但是这个概念一直比较模糊，这里就趁着这篇文章来梳理一下。 1、Java线程生命周期 说好的讲synchronized的呢，怎么开篇就是生命周期问题呢？要讲清楚synchronized必须要搞清楚Java线程生命周期问题...
同步控制——synchronized关键字
qq_34459728的博客
03-09 1375
同步是java中一个很重要的知识点，也是比较难以理解的知识点。经常在学会了，学忘了，学废了之间循环，抽点时间系统的整理一下同步的知识点，梳理一下逻辑 synchronized关键字 先看看这个synchronized关键字，synchronized有五种比较常用的方法 修饰代码块 修饰变量 修饰普通方法 修饰静态方法 修饰类 先来看看修饰代码块 ...
synchronized对象锁的同步和异步问题
木村的博客
11-03 6819
先上代码:public class MyObject { public synchronized void method1(){ try { System.out.println(Thread.currentThread().getName()); Thread.sleep(4000); } catch (Int
Synchronized关键字的使用区别
damokelisijian866的博客
06-10 485
Synchronized关键字的使用区别 常用API method 注释 run() run()方法是我们创建线程时必须要实现的方法，但是实际上该方法只是一个普通方法，直接调用并没有开启线程的作用。 start() start()方法作用为使该线程开始执行；Java虚拟机调用该线程的 run 方法。 但是该方法只能调用一次，如果线程已经启动将会抛出IllegalThreadStateException异常。 yield() yield()方法让出CPU并且不会释放锁，让当前线程变为可
详解synchronized与Lock的区别与使用
热门推荐
brickworkers的博客
03-22 21万+
引言： 昨天在学习别人分享的面试经验时，看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是，我整理了两者的区别和使用情况，同时，对synchronized的使用过程一些常见问题的总结，最后是参照源码和说明文档，对Lock的使用写了几个简单的Demo。请大家批评指正。 技术点： 1、线程与进程： 在开始之前先把进程与线程进行区分一下，一个程序最...
Java: synchronized详解，静态同步方法，普通同步方法，同步代码块
ahsxsk的学习之路
03-11 3201
摘自：http://topmanopensource.iteye.com/blog/1738178 对代码进行同步控制我们可以选择同步方法，也可以选择同步块，这两种方式各有优缺点，至于具体选择什么方式，就见仁见智了，同步块不仅可以更加精确的控制对象锁，也就是控制锁的作用域，何谓锁的作用域？锁的作用域就是从锁被获取到其被释放的时间。而且可以选择要获取哪个对象的对象锁。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hi，all

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值