java synchronized锁的对比

最新推荐文章于 2021-04-09 12:30:05 发布
最新推荐文章于 2021-04-09 12:30:05 发布
阅读量293 收藏 1
点赞数 1
分类专栏： java基础知识 文章标签： java class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiangming_10010/article/details/77544364
版权

synchornized常用的方法的对比。

一 给静态方法和普通方法加锁

加锁的类

public class LockText {

    public synchronized void printCount(){
        int i=0;
        while(i<50){
            System.out.println(Thread.currentThread()+"ynt---"+i);
            i++;
        }
    }

    public synchronized void printString(){
        int i=0;
        while(i<50){
            System.out.println(Thread.currentThread()+"ynt===");
            i++;
        }
    }
    public synchronized static void printChar(){
        char xx=65;
        int i=65;
        while(i<91){
            System.out.println(Thread.currentThread()+"ynt++++"+xx);
            xx++;
            i++;
        }
    }
}

调用类


public class MainText {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        final LockText text=new LockText();
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                    text.printCount();

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                    text.printString();             

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                LockText.printChar();
            }
        }).start();
    }
}

运行结果部分截图

Thread[Thread-0,5,main]ynt---42
Thread[Thread-2,5,main]ynt++++W
Thread[Thread-0,5,main]ynt---43
Thread[Thread-2,5,main]ynt++++X
Thread[Thread-0,5,main]ynt---44
Thread[Thread-2,5,main]ynt++++Y
Thread[Thread-0,5,main]ynt---45
Thread[Thread-2,5,main]ynt++++Z
Thread[Thread-0,5,main]ynt---46
Thread[Thread-0,5,main]ynt---47
Thread[Thread-0,5,main]ynt---48
Thread[Thread-0,5,main]ynt---49
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===

结论：
1.对不同的非静态方法加锁，不能同时访问
2.对静态方法和非静态方法同时加锁，可同时访问

二 对类加锁

加锁类

public class LockText {

    public  void printCount(){
        int i=0;
        while(i<50){
            System.out.println(Thread.currentThread()+"ynt---"+i);
            i++;
        }
    }

    public  void printString(){
        int i=0;
        while(i<50){
            System.out.println(Thread.currentThread()+"ynt===");
            i++;
        }
    }
    public  static void printChar(){
        char xx=65;
        int i=65;
        while(i<91){
            System.out.println(Thread.currentThread()+"ynt++++"+xx);
            xx++;
            i++;
        }
    }
}

调用类

public class MainText {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        final LockText text=new LockText();
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (LockText.class) {
                    text.printCount();

                }

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (LockText.class) {
                    text.printString();             

                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (LockText.class) {
                    LockText.printChar();

                }
            }
        }).start();
    }
}

部分运行结果

Thread[Thread-0,5,main]ynt---45
Thread[Thread-0,5,main]ynt---46
Thread[Thread-0,5,main]ynt---47
Thread[Thread-0,5,main]ynt---48
Thread[Thread-0,5,main]ynt---49
Thread[Thread-2,5,main]ynt++++A
Thread[Thread-2,5,main]ynt++++B
Thread[Thread-2,5,main]ynt++++C
Thread[Thread-2,5,main]ynt++++D
Thread[Thread-2,5,main]ynt++++E
Thread[Thread-2,5,main]ynt++++F
Thread[Thread-2,5,main]ynt++++G
Thread[Thread-2,5,main]ynt++++H
Thread[Thread-2,5,main]ynt++++I
Thread[Thread-2,5,main]ynt++++J
Thread[Thread-2,5,main]ynt++++K
Thread[Thread-2,5,main]ynt++++L
Thread[Thread-2,5,main]ynt++++M
Thread[Thread-2,5,main]ynt++++N
Thread[Thread-2,5,main]ynt++++O
Thread[Thread-2,5,main]ynt++++P
Thread[Thread-2,5,main]ynt++++Q
Thread[Thread-2,5,main]ynt++++R
Thread[Thread-2,5,main]ynt++++S
Thread[Thread-2,5,main]ynt++++T
Thread[Thread-2,5,main]ynt++++U
Thread[Thread-2,5,main]ynt++++V
Thread[Thread-2,5,main]ynt++++W
Thread[Thread-2,5,main]ynt++++X
Thread[Thread-2,5,main]ynt++++Y
Thread[Thread-2,5,main]ynt++++Z
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5

结论
对类加锁静态方法和非静态方法都是同步的

三 对对象加锁

加锁类同二

调用类


public class MainText {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        final LockText text=new LockText();
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (text) {
                    text.printCount();
                }

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (text) {
                    text.printString();             

                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (text) {
                    LockText.printChar();
                }
            }
        }).start();
    }
}

运行结果

运行结果同二

结论：静态方法和非静态方法是同步的

四 简单的 加锁对象加锁类

加锁类同上
public class MainText {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        final LockText text=new LockText();
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (LockText.class) {
                    text.printCount();
                }

            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (text) {
                    text.printString();             

                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (text) {
                    LockText.printChar();

                }
            }
        }).start();
    }
}

运行结果

Thread[Thread-1,5,main]ynt===
Thread[Thread-0,5,main]ynt---45
Thread[Thread-1,5,main]ynt===
Thread[Thread-0,5,main]ynt---46
Thread[Thread-1,5,main]ynt===
Thread[Thread-0,5,main]ynt---47
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-0,5,main]ynt---48
Thread[Thread-1,5,main]ynt===
Thread[Thread-0,5,main]ynt---49
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-1,5,main]ynt===
Thread[Thread-2,5,main]ynt++++A
Thread[Thread-2,5,main]ynt++++B
Thread[Thread-2,5,main]ynt++++C
Thread[Thread-2,5,main]ynt++++D
Thread[Thread-2,5,main]ynt++++E
Thread[Thread-2,5,main]ynt++++F
Thread[Thread-2,5,main]ynt++++G
Thread[Thread-2,5,main]ynt++++H
Thread[Thread-2,5,main]ynt++++I

结论 对象锁和类锁不同步

所以对synchronized总结如下：
1.synchronized加到对象上只能锁对象，不同的对象锁不相同因此不同步（代码没贴）
2.synchronized加到类上锁定当前类，静态方法和非静态方法都同步
3.synchronized加到类的不同非静态方法上，方法同步
4.synchronized加到类的静态方法和非静态方法上，他们不同步

sea-lavender
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java sync_Java中Synchornize关键字原理
weixin_29300931的博客
03-06 367
在实际开发中，往往需要考虑数据并发安全问题，比如秒杀业务场景、买票业务场景，都需要考虑并发，Java提供了Synchornize关键字来为我们解决了并发性问题.本文讲解Synchornize关键字的工作原理一、Java对象头和MonitorJVM中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充。jvm.png实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分，还...
Java内置锁 synchronized
liu_shi_jun的专栏
04-15 443
synchronized 同步代码块组成       在上一篇文章： 线程安全性的基本概念中，讲到过当多个线程访问状态变量，并且至少有一个线程会修改变量的值时，就需要采用同步机制来协调这些线程对对象的访问。这里说的”同步机制“包括：synchronized关键字、volatile变量、显式锁、ThreadLoacl变量以及原子变量。       今天梳理一下synchronized 关键字
Synchronized
半桶水的博客
04-09 1270
目录 一、synchronized的简单介绍 二、synchronized应用 三、synchronized原理 四、synchronized的改进与优化 五、syncchronized的深度思考 一、synchronized的简单介绍 关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要
详解synchronized锁的各种用法及注意事项
biaolianlao0449的博客
02-06 309
【源码笔记】 专注于Java后端系列框架的源码分析，关注【源码笔记】公众号，第一时间接收最新源码分析文章更新。Github地址：https://github.com/yuanmabiji/Java-SourceCode-Blogs 1 前言 本文主要通过简单的demo来阐述synchronized锁的各种用法以及使用synchronized锁的相关注意事项，记录下来同时也方便自己记忆。 synchronized锁是jvm内置的锁，不同于ReentrantLock锁。synchronized关键字可以修饰.
java中锁和synchorized的底层实现
我的博客
06-12 1804
java中要实现线程同步有两种方式：(显性锁)锁和(隐性锁)synchorized。 synchnorized关键字：包括两种方式同步方法和同步代码块，它包括两种加锁方式，锁对象和锁类。 (1)如果一个synchnorized的锁作用域是一个实例对象，假如该实例对象有多个synchorized方法或代码块，只要一个线程访问了该对象的一个synchorized方法(代码块)，其它线程就不再能访问...
Synchornized使用及原理
qianwenhong
06-04 3152
同步，可见，synchornized，volatile
java Lock（与synchronized作比较）
m0_46430075的博客
11-26 82
文章目录一、synchronized的缺陷二、java.util.concurrent.locks包下常用的类1.Lock2.ReentrantLock3.ReadWriteLock4.ReentrantReadWriteLock5.Lock和synchronized的选择三、锁的相关概念介绍1.可重入锁2.可中断锁3.公平锁4.读写锁 一、synchronized的缺陷      synchronized是java中的一个关键字，也就是说是Java语言内置
Java各种锁的使用方式及其对比
最新发布
05-29
Java提供了多种类型的锁，包括 `synchronized` 块，可重入锁，读写锁和印章锁等。这些锁可以用来控制对共享资源的访问，从而保证数据一致性和线程安全。 在程序中使用锁需要注意锁定的粒度和时长，过大的锁粒度或...
lock锁，lock锁和synchronized的对比
11-19
# synchronized锁与lock锁的对比 Lock是显式锁，需要手动的开启和关闭，synchronized锁是隐式锁，只要出了作用域就会自动释放。Lock只有代码块锁，synchronized既有代码块锁还有方法锁。 使用Lock锁，JVM将花费较...
Java synchronized使用案例
01-16
四、`synchronized`与其他并发工具类的对比 1. **ReentrantLock**：具有`synchronized`的可重入性，并且提供公平锁、非公平锁选择，支持尝试获取锁、中断锁等待等高级功能。 2. **Semaphore**：信号量，可以控制同时...
[JAVA][synchronized的使用]
06-21
- **ReentrantLock**：是Java并发包`java.util.concurrent.locks`中的可重入锁，提供了比`synchronized`更细粒度的控制，支持公平锁和非公平锁，以及可中断和可定时的获取锁。 7. **TestSynchronized 示例** 通常...
Java锁的升级策略 偏向锁 轻量级锁 重量级锁
08-25
这些锁状态都是专门针对Synchronized关键字的，是为了提高获得锁和释放锁的效率。 首先，无锁状态是指没有任何锁的状态。然后，偏向锁是指锁状态中的一种，基于轻量级锁进行了优化，假设整个过程只有一个线程获得锁...
Java中的同步与互斥机制--synchornized学习
Sam的专栏
10-11 7129
    Java关键字synchronized是Java 语言提供的对多线程和同步的一种机制。synchronized可以作为函数的修饰符，也可作为函数内的语句。它可以作用于instance变量，对象引用（object reference），static函数和类名称字面常量（class literals）。  下面介绍一下synchronized的关键字的使用方法：一、synchroniz
透彻理解 Java synchronized 对象锁和类锁的区别
热门推荐
zhujiangtaotaise的专栏
02-17 2万+
synchronized 加到 static 方法前面是给class 加锁，即类锁；而synchronized 加到非静态方法前面是给对象上锁。这两者的区别我用代码来演示下： 对象锁和类锁是不同的锁，所以多个线程同时执行这2个不同锁的方法时，是异步的。 在Task2 中定义三个方法 doLongTimeTaskA和doLongTimeTaskB是类锁，而doLongTimeTaskC是对象锁。pub
java synchronized详解
Jerry的博客
05-29 307
：synchronized锁住的是代码还是对象。答案是：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。 当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。即使两个不同的代码段，都要锁同一个对象，那么
lock和synchornized教程
不甘平庸的人
06-23 485
http://blog.csdn.net/fw0124/article/details/6672522
synchronized()_synchronized和锁(ReentrantLock) 区别
weixin_39635432的博客
11-23 174
区别一：API层面synchronized使用synchronized既可以修饰方法，也可以修饰代码块。 synchronized修饰方法时，如下所示：//synchronized修饰一个方法时，这个方法叫同步方法。public synchronized void test() {//方法体``}synchroized修饰代码块时，包含两部分：锁对象的引用和这个锁保护的代码块。如下所示：synch...
Java 多线程/并发 Synchronized学习笔记
zamaochick的博客
11-06 595
synchronized关键字可以添加在方法的声明上，也可以添加在代码块中 添加在方法上时分两种情况，当为静态方法时，表示的是对该类的.class对象上锁 当不为静态方法时，表示的是对该类的对象上锁。 添加在代码块时，需要指定上锁的对象。 public class Synchonizedd { static Long start,end; static { ...
ReentrantLock的四种加锁方式
谈下一个话题，假如.......
10-29 5618
ReentrantLock的四种加锁方式
synchronized和lock对比
04-24
下面是 `synchronized` 和 `Lock` 的一些对比: 1. 使用方法不同：`synchronized` 关键字是 Java 的内置关键字，可以直接使用；而 `Lock` 是 Java 的一个类，需要通过实例化来使用。 2. 加锁方式不同：`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值