线程八锁（非静态同步方法与静态同步方法的区别）

最新推荐文章于 2021-10-19 20:59:36 发布
最新推荐文章于 2021-10-19 20:59:36 发布
阅读量384 收藏 2
点赞数 1
分类专栏： 并发&JUC 文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_eryue/article/details/108118253
版权

所为线程八锁是指在工作中锁的几种情况，网上搜了好多，发现列举的八个代码实例，有不少代码实例都可有可无的，但是呢，为了完整地记录下这次的学习，那我写也写全吧，手动苦笑~~，请看列子

1.同一个对象，开启两个线程，分别调用两个非静态同步方法

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 * 两个线程调同一个对象的两个同步方法
 *
 * 原因分析：锁的对象是方法的调用者，即t8l，所以两个方法用的是同一个锁，因此先调用的先执行
 */
public class Lock1 {

    public static void main(String[] args) {
        Test8Lock1 t8l = new Test8Lock1();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getTwo();
            }
        }).start();
    }

}
class Test8Lock1{
    public synchronized  void getOne(){
        System.out.println("-->one");
    }

    public synchronized  void getTwo(){
        System.out.println("-->two");
    }
}

输出：

总结：被synchronized修饰的非静态方法，锁的是调用者本身

2.在1的基础上，给getOne增加了休眠期（其实就是为了再次验证1的结论）

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 * 锁的同一个对象，先持有锁的先执行
 */
public class Lock2 {

    public static void main(String[] args) {
        Test8Lock2 t8l = new Test8Lock2();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getTwo();
            }
        }).start();
    }

}
class Test8Lock2{
    public synchronized  void getOne(){
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public synchronized  void getTwo(){
        System.out.println("-->two");
    }
}

输出：

3.同一个对象调用非静态同步方法与普通方法

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 * 同一个对象调用同步方法与普通方法
 * <p>
 * 原因分析：普通方法不受锁的影响
 */
public class Lock3 {

    public static void main(String[] args) {
        Test8Lock3 t8l = new Test8Lock3();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getTwo();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getThree();
            }
        }).start();
    }

}

class Test8Lock3 {
    public synchronized void getOne() {
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public synchronized void getTwo() {
        System.out.println("-->two");
    }

    public void getThree() {
        System.out.println("-->three");
    }
}

输出：

总结：普通方法不受锁影响

4.两个不同的对象分别调用非静态同步方法

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 * 两个线程分表调用两个对象的同步方法
 * <p>
 * 原因分析：锁的对象不同，各自执行各自的
 */
public class Lock4 {

    public static void main(String[] args) {

        Test8Lock3 t8l1 = new Test8Lock3();
        Test8Lock3 t8l2 = new Test8Lock3();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l1.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l2.getTwo();
            }
        }).start();


    }

}

class Test8Lock4 {
    public synchronized void getOne() {
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public synchronized void getTwo() {
        System.out.println("-->two");
    }

}

输出：


 总结：通过1我们知道，非静态同步方法锁的是调用者本身，而本列中，锁得是不同的对象，因此two先输出，再次验证1的结论~_~

5.同一个对象分别调用静态同步方法和非静态同步方法

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 *
 * <p>
 * 原因分析：static 修饰的同步方法锁的是class，单synchronized锁的是调用者本身
 */
public class Lock5 {

    public static void main(String[] args) {
        Test8Lock5 t8l = new Test8Lock5();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getTwo();
            }
        }).start();

    }

}

class Test8Lock5 {
    public static synchronized void getOne() {
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public synchronized void getTwo() {
        System.out.println("-->two");
    }

}

输出：

总结：咦~，这不是用一个对象的调用吗，怎么会这样呢，哈哈，这里又是另一个重要的结论：静态同步方法锁的是class，再结合1的结论（非静态同步方法锁的是调用者本身，即t8l），因此，本列中实际上是锁的不同对象，一个是实例对象t8l，一个是class（或者应该说是不同的锁）

6.同一个对象分别调用两个静态同步方法

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 *
 * <p>
 * 原因分析：static 修饰的同步方法锁的是class，
 */
public class Lock6 {

    public static void main(String[] args) {
        Test8Lock6 t8l = new Test8Lock6();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l.getTwo();
            }
        }).start();

    }

}

class Test8Lock6 {
    public static synchronized void getOne() {
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public static synchronized void getTwo() {
        System.out.println("-->two");
    }

}

输出：

进一步验证5的结论

7.两个不同的对象分别调用静态同步方法和非静态同步方法

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 *
 * <p>
 * 原因分析：static 修饰的同步方法锁的是class，
 */
public class Lock7 {

    public static void main(String[] args) {
        Test8Lock7 t8l1 = new Test8Lock7();
        Test8Lock7 t8l2 = new Test8Lock7();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l1.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l2.getTwo();
            }
        }).start();

    }

}

class Test8Lock7 {
    public static synchronized void getOne() {
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public  synchronized void getTwo() {
        System.out.println("-->two");
    }

}

输出：

可充分验证5的结论

8.两个不同的对象分别调用两个静态同步方法

 

package com.cjian.thread8lock;

/**
 * Created by cjian on 2020/8/20.
 *
 * <p>
 * 原因分析：static 修饰的同步方法锁的是class，
 */
public class Lock8 {

    public static void main(String[] args) {
        Test8Lock8 t8l1 = new Test8Lock8();
        Test8Lock8 t8l2 = new Test8Lock8();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l1.getOne();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t8l2.getTwo();
            }
        }).start();

    }

}

class Test8Lock8 {
    public static synchronized void getOne() {
        try {
            System.out.println("-->sleep 1s");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-->one");
    }

    public static synchronized void getTwo() {
        System.out.println("-->two");
    }

}

输出：

再次充分验证静态同步方法锁的是class

 

总结：非静态同步方法锁的是调用者对象本身，静态同步方法锁的是class 

cj_eryue
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
同步静态和非静态同步的区别
nyist_12138的专栏
06-24 783
同步静态和非静态同步的区别
java synchronized静态同步方法与非静态同步方法，同步语句块
wwwwwww31311的博客
01-30 2599
对代码进行同步控制我们可以选择同步方法，也可以选择同步块，这两种方式各有优缺点。同步块不仅可以更加精确的控制对象锁，还可以控制锁的作用域，何谓锁的作用域？锁的作用域就是从锁被获取到其被释放的时间。而且可以选择要获取哪个对象的对象锁。但是如果在使用同步块机制时，如果使用过多的锁也会容易引起死锁问题，同时获取和释放所也有代价，而同步方法，它们所拥有的锁就是该方法所属的类的对象锁，换句话说，也就是this对象，而且锁的作用域也是整个方法，这可能导致其锁的作用域可能太大，也有可能引起死锁，同时因为可能包含了不需要进
synchronized用于静态方法和普通方法区别
fulai00的专栏
06-30 2163
所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。 而所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个
同步代码块、静态同步方法、非静态同步方法的区别
weixin_43771403的博客
10-19 486
静态同步方法：静态同步方法的锁是当前类的字节码文件(类名.class)； 非静态同步方法：非静态同步方法的锁是this； 同步代码块：同步代码块可以使用自定义的Object对象，也可以使用this或者当前类的字节码文件(类名.class)； 通过修改下面代码进行验证 public class ClassLock { public static void main(String[] args) { ClassLock classLock1 = new ClassLock();
线程静态同步与非静态差别
小狮子-专栏
01-07 702
那么，在static方法和非static方法前面加synchronized到底有什么不同呢？ 大家都知道，static的方法属于类方法，它属于这个Class(注意：这里的Class不是指Class的某个具体对 象)，那么static获取到的锁，就是当前调用这个方法的对象所属的类(Class，而不再是由这个Class产生 的某个具体对象了)。而非static方法获取到的锁，就是当前调用
静态方法同步 与 非静态方法同步
08-03
例如，`SynchronizedTest.java`中可能有以下非静态同步方法： ```java public class SynchronizedTest { private int count; public synchronized void incrementCount() { count++; } } ``` 在选择同步方法...
C#静态方法与非静态方法实例分析
10-25
在C#编程语言中，了解和掌握静态方法与非静态方法是至关重要的，因为它们各自有不同的特性和使用场景。静态方法和非静态方法是类中定义的两种主要方法类型。 1. 静态方法（Static Methods） - 定义：使用`static`...
基于synchronized修饰静态和非静态方法
08-19
情况3：一个对象在两个线程中分别调用一个静态同步方法和一个非静态同步方法结果：不会产生互斥。解释：因为虽然是一个对象调用，但是两个方法的锁类型不同，调用的静态方法实际上是类对象在调用，即这两个方法产生...
java多线程编程之使用Synchronized块同步方法
09-04
在内部类（InnerClass）中，如果需要与外部类的非静态方法同步，可以使用`OuterClass.this`作为同步锁，例如： ```java public class SyncBlock { class InnerClass { public void innerMethod() { synchronized...
java synchronized同步静态方法和同步非静态方法的异同
08-31
本文将深入探讨`synchronized`关键字在同步静态方法和非静态方法上的异同。 首先，`synchronized`关键字有两种主要的使用方式：一是修饰方法，二是作为代码块。当`synchronized`修饰一个非静态方法时，锁住的是该...
Synchronized同步静态方法和非静态方法总结
热门推荐
u010842515的博客
03-23 4万+
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。        Java中每个对象都有一个锁，并且是唯一的。假设分配的一个对象空间，里面有多个方法，相当于空间里面有多个小房间，如果我们把所有的小房间都加锁，因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。 情况1：同一个
java synchronized（静态同步方法、非静态同步方法及同步块）
蓝田日暖玉生烟
10-19 3933
同步方法   同步方法所拥有的锁就是该方法所属的类的对象锁，换句话说，也就是this对象，而且锁的作用域也是整个方法，这可能导致其锁的作用域可能太大，也有可能引起死锁，同时因为可能包含了不需要进行同步的代码块在内，也会降低程序的运行效率。 同步方法的锁   同步方法分为静态同步方法与非静态同步方法。 非静态同步方法   所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例...
同步代码块，同步方法，同步静态方法，同步非静态方法的区别
wang_keng的博客
08-21 4415
首先关于锁和同步，有一下几个要点： 1）、只能同步方法，而不能同步变量和类； 2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？ 3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。 4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一
两个线程同时访问一个对象的静态同步方法和非静态同步方法(synchronized）
绅士jiejie的博客
02-22 1119
示例代码 public class TestMain implements Runnable { //格式化 static SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); @Override public void run() { //让线程Thread-0...
静态同步方法与非静态同步方法的区别
kenwu的专栏
05-13 1273
有时，我们经常会碰到这样的代码！ java 代码  public class A {       public static synchronized void testStatic() {           //...       }          public synchronized void testNonS
静态方法和非静态方法区别？
SeniorShen的博客
08-24 2万+
静态方法static（类方法）和 非静态方法（实例方法）的区别： 方法我们主要分为三种： 1.构造方法 2.非静态方法（普通方法/实例方法） 3.静态方法（类方法） 对于1（补充一下）：构造方法分为无参构造方法 和 有参构造方法。另外 这两个方法，涉及到了方法重载（小伙伴可以自己去了解方法重载、方法重写、方法重构区别，当然我其他文章也会写相关的介绍）。 对于2：静态方法，是使用static关键字修...
Java多线程-44-静态和非静态方法同步锁对象是什么
Anthony_tester的博客
10-09 3237
前面一篇，我们知道了synchronized关键字扩起来范围的代码块就可以实现同步，其实，在Java中，只需要在方法上加上synchronized关键字即可，就像加上static一样。本篇来看看加上synchronized关键字修饰的非静态和静态方法的同步锁对象是什么。 1.非静态同步锁对象是this 复制前面一篇代码，修改如下。 package thread; public class...
java synchronized同步静态方法和同步非静态方法的区别与举例
yunfuyiren的专栏
03-12 3643
synchronized关键字是java并发编程中为了解决线程对共享资源的竞争造成错误，而提供的解决方案。synchronized关键字有两种用法，一种是只用于方法的定义中，另外一种是synchronized块，我们不仅可以使用synchronized来同步一个对象变量，你也可以通synchronized来同步类中的静态方法和非静态方法。那么问题来了，同步静态方法与动态方法有什么区别呢？看完下面这
静态同步方法和非静态同步方法有什么区别
最新发布
05-29
当一个线程进入非静态同步方法时，它会尝试获取该方法所属对象的实例对象的锁，如果获取成功，其他线程就无法进入该非静态同步方法，只有等待锁被释放。 因此，静态同步方法和非静态同步方法的区别在于它们锁定的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值