static synchronized方法和synchronized方法的区别和联系-1（相同锁下的访问比较）

最新推荐文章于 2023-04-04 14:28:31 发布
最新推荐文章于 2023-04-04 14:28:31 发布
阅读量511 收藏
点赞数
分类专栏： java 高并发多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011066470/article/details/105868808
版权

1.1  synchronized修饰的普通方法---------被同一个对象实例访问

package com.ljf.mianshi.demo.mainshithread;

public class TestJd {
    public static void main(String args[]){
        JDSB jdsb=new JDSB();
        JDSB jdsb2=new JDSB();
        new Thread(new ThreadA(jdsb),"A").start();
        new Thread(new ThreadB(jdsb),"B").start();

    }

}

package com.ljf.mianshi.demo.mainshithread;

public class JDSB {


    public  synchronized void   sayA() {
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我开始执行sayA");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我离开sayA");
    }


}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadA implements Runnable {
    JDSB jdsb=null;
    public ThreadA(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadB implements Runnable {
    JDSB jdsb=null;
    public ThreadB(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}

结果：

我是线程:A我开始执行sayA
我是线程:A我离开sayA
我是线程:B我开始执行sayA
我是线程:B我离开sayA
结论：synchronized修饰普通方法，使用同一对象访问，那么结果是同步的。

1.2  synchronized修饰的普通方法---------被不同对象实例访问

package com.ljf.mianshi.demo.mainshithread;

public class TestJd {
    public static void main(String args[]){
        JDSB jdsb=new JDSB();
        JDSB jdsb2=new JDSB();
        new Thread(new ThreadA(jdsb),"A").start();
        new Thread(new ThreadB(jdsb2),"B").start();

    }

}
package com.ljf.mianshi.demo.mainshithread;

public class JDSB {


    public  synchronized void   sayA() {
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我开始执行sayA");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我离开sayA");
    }


}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadA implements Runnable {
    JDSB jdsb=null;
    public ThreadA(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadB implements Runnable {
    JDSB jdsb=null;
    public ThreadB(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}

结果：

我是线程:B我开始执行sayA
我是线程:A我开始执行sayA
我是线程:B我离开sayA
我是线程:A我离开sayA
结论：synchronized修饰普通方法，使用不同对象访问，那么结果是异步的。不同的对象使用各自的锁。

比较1.1和1.2得出的结论为：synchronized修饰不加static的普通方法时使用的锁是this对象，使用同一对象访问，那么结果是同步的，使用的是同一把锁，使用不同对象访问，那么结果是异步的。不同的对象使用各自的锁，不同的对象没有竞争关系；

1.3  synchronized修饰static的方法---------被同一对象实例访问

package com.ljf.mianshi.demo.mainshithread;

public class TestJd {
    public static void main(String args[]){
        JDSB jdsb=new JDSB();
        JDSB jdsb2=new JDSB();
        /** synchronized关键字加到static静态方法上是给Class类(class字节码文件)上锁,
         * 而Class锁可以对类的所有对象实例起作用
         */
        new Thread(new ThreadA(jdsb),"A").start();
        new Thread(new ThreadB(jdsb),"B").start();

    }

}
package com.ljf.mianshi.demo.mainshithread;

public class JDSB {


    public static synchronized void   sayA() {
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我开始执行sayA");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我离开sayA");
    }


}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadA implements Runnable {
    JDSB jdsb=null;
    public ThreadA(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}

package com.ljf.mianshi.demo.mainshithread;

public class ThreadB implements Runnable {
    JDSB jdsb=null;
    public ThreadB(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}

结果:

我是线程:A我开始执行sayA
我是线程:A我离开sayA
我是线程:B我开始执行sayA
我是线程:B我离开sayA

1.4  synchronized修饰static的方法---------被不同对象实例访问

package com.ljf.mianshi.demo.mainshithread;

public class TestJd {
    public static void main(String args[]){
        JDSB jdsb=new JDSB();
        JDSB jdsb2=new JDSB();
        /** synchronized关键字加到static静态方法上是给Class类(class字节码文件)上锁,
         * 而Class锁可以对类的所有对象实例起作用
         */
        new Thread(new ThreadA(jdsb),"A").start();
        new Thread(new ThreadB(jdsb2),"B").start();
       

    }

}
package com.ljf.mianshi.demo.mainshithread;

public class JDSB {


    public static synchronized void   sayA() {
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我开始执行sayA");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是线程:"+Thread.currentThread().getName()+"我离开sayA");
    }


}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadA implements Runnable {
    JDSB jdsb=null;
    public ThreadA(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}
package com.ljf.mianshi.demo.mainshithread;

public class ThreadB implements Runnable {
    JDSB jdsb=null;
    public ThreadB(JDSB jdsb) {
        this.jdsb=jdsb;
    }

    @Override
    public void run() {
        jdsb.sayA();
    }
}

经过1.3和1.4比较可得:而两个对象是同一个class文件，所以使用的是一个锁。

synchronized关键字加到static静态方法上是给Class类(class字节码文件)上锁,而Class锁可以对类的所有对象实例起作用,类锁就是要控制类的所有实例的并发访问，这个类所有的对象竞争一把锁。

参考地址：

https://blog.csdn.net/ROAOR1/article/details/88845700

https://www.cnblogs.com/hongdalin/p/11492192.html

健康平安的活着
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于synchronized修饰静态和非静态方法
08-19
主要介绍了基于synchronized修饰静态和非静态方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
synchronized与static synchronized的区别
01-20
当某个线程调用synchronized方法的时候，就会给它加上了一个锁，其他线程就会无法访问，等到这个锁被释放，别的线程拿到这个锁的时候，才可以访问该方法。 static synchronized这个是“全局锁”或者是“类锁”，该锁...
Java中synchronized 用在static方法和非static方法上面的区别
Alen
08-20 2559
在Java中，synchronized是用来表示同步的，我们可以synchronized来修饰一个方法。也可以synchronized来修饰方法里面的一个语句块。那么，在static方法和非static方法前面加synchronized到底有什么不同呢？大家都知道，static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对象），那么static获取到的锁......
浅析Java中synchronized与static synchronized
C18298182575的博客
11-25 696
synchronized VS static synchronized
Synchronized三种使用方式
m0_59164927的博客
08-14 1443
两个方法methods01锁住test实例对象,methods02锁住test02对象，methods02没有sleep先打印。结果说明:两个方法调用同一个锁，即锁的this，被methods01抢夺后，methods02进入等待。methods01拿类锁，methods02拿对象锁,methods02不用等待。static锁住类对象，只有一个,需要等待methods01执行完。hello没加锁不用等待methods01执行完。结果说明：methods01先调用，先执行。...
synchronized 与 static synchronized 的区别
祈祷之手
07-05 644
目录 静态锁 静态锁+Class对象锁 普通锁 普通锁+this对象锁 静态锁+普通锁 首先synchronized 锁的一定是某个对象, 本节讨论的是下面两个情况 public class SyncType{ public synchronized void syncCurrent() { } public synchronized stat...
深入理解Synchronized（对象锁）和Static Synchronized（类锁）的区别
Darling_qi的博客
03-20 1613
通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）。
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
主要介绍了Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别，希望对大家有所帮助，一起跟随小编过来看看吧
Java中synchronized关键字修饰方法同步的用法详解
09-02
synchronized可以用来同步静态和非静态方法,下面就具体来看一下Java中synchronized关键字修饰方法同步的用法详解:
synchronized锁原理分析（二、锁的膨胀过程）
12-21
继续承接上一篇博客一、从Java对象头看synchronized锁的状态 先通过几个案例，从结果直观的展示锁是如何膨胀的 最后将锁的膨胀过程通过一张流程图展示出来 案例1（无锁，不可偏向状态） import org.openjdk.jol....
关于synchronized同步方法
maimai的博客
05-04 365
修饰同步方法：作用于当前实例加锁，进入同步代码前要获得当前实例的锁。 public class TestThread { public synchronized void car1(){ System.out.println(Thread.currentThread()+"获得资源"); try { Thread.currentThread().sleep(3000); } catch (InterruptedExcepti
java 静态同步锁static synchronized详解
hello_v_world的博客
07-07 2211
下面我们看例子1： 有一个phone类，里面有两个同步方法（synchronized修饰），分别为发送email和发送短信，在main方法中实例化一部手机，开启两个线程去操作phone这个资源类 public class Phone { public synchronized void sendMail() throws Exception { TimeUnit.SECONDS.sleep(4); System.out.println("******sendMail
synchronized与static synchronized详解
热门推荐
博学de叫兽
10-31 1万+
synchronized与static synchronized的区别 synchronized是实例锁，对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块。 注意这里是类的当前实例， 类的两个不同实例就没有这种约束了 static synchronized是类锁，控制类的所有实例的并发访问，限制多线程中该类的所有实例同时访问JVM中该类所对应的代...
synchronized修饰静态方法与实例方法
meser88的博客
04-04 624
一、synchronized修饰实例方法：synchronized修饰实例方法，实际上是对调用该方法的对象加锁。场景1：同一实例对象在两个线程中分别调用该对象的两个同步实例方法。
java synchronized静态同步方法与非静态同步方法，同步语句块
wwwwwww31311的博客
01-30 2560
对代码进行同步控制我们可以选择同步方法，也可以选择同步块，这两种方式各有优缺点。同步块不仅可以更加精确的控制对象锁，还可以控制锁的作用域，何谓锁的作用域？锁的作用域就是从锁被获取到其被释放的时间。而且可以选择要获取哪个对象的对象锁。但是如果在使用同步块机制时，如果使用过多的锁也会容易引起死锁问题，同时获取和释放所也有代价，而同步方法，它们所拥有的锁就是该方法所属的类的对象锁，换句话说，也就是this对象，而且锁的作用域也是整个方法，这可能导致其锁的作用域可能太大，也有可能引起死锁，同时因为可能包含了不需要进
同一个类里面两个synchronized方法，两个线程同时访问的问题
suncat的博客
07-29 9010
代码如上所示，MyObject类有两个方法，分别创建两个线程调用方法A和方法B： 会有以下几种情况： 1、两个方法都没有synchronized修饰，调用时都可进入：方法A和方法B都没有加synchronized关键字时，调用方法A的时候可进入方法B； 2、一个方法有synchronized修饰，另一个方法没有，调用时都可进入：方法A加synchronized关键字而方法B没有加...
一个类里的两个synchronized方法
rightrat的专栏
05-26 5294
同一实例的两个synchronized方法不可以被两个线程同时访问，因为对象锁被占用。也就是说，同一时刻，同一实例（注意，不是同一个类）的多个synchronized方法最多只能有一个被访问。实例代码如下：public class TwoSynchronizedMethodInOneClassTest { private static int counter = 0; publ
static 与 synchronized修饰同一个方法
zjyfree的博客
12-09 764
学习笔记
static synchronized和synchronized的区别
最新发布
10-11
static synchronized和synchronized是两种不同的关键字，用于实现线程同步。它们之间的区别如下： 1. synchronized关键字： - synchronized关键字用于修饰方法或代码块，用于实现对象级别的锁定。 - 当一个线程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值