synchronized使用

最新推荐文章于 2022-10-27 14:28:35 发布
最新推荐文章于 2022-10-27 14:28:35 发布
阅读量102 收藏
点赞数
分类专栏： java 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31391225/article/details/108625298
版权

1、 synchronized关键字使用在方法上面，代码如下

@Slf4j(topic = "test")
public class BasicLock {

    public synchronized void x(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("x");
    }

    public synchronized void y(){
        log.debug("y");
    }

    public void z(){
        log.debug("z");
    }
}

测试类

@Slf4j(topic = "test")
public class TestBasic2 {
    public static void main(String[] args) {
        BasicLock basicLock = new BasicLock();


        new Thread(()->{
            log.debug("start");
            basicLock.x();
        },"t1").start();

        new Thread(()->{
            log.debug("start");
            basicLock.y();
        },"t2").start();

        new Thread(()->{
            log.debug("start");
            basicLock.z();
        },"t3").start();
    }
}

打印结果如下

第一次执行

16:37:26.219 [t1] DEBUG test - start
16:37:26.219 [t2] DEBUG test - start
16:37:26.219 [t3] DEBUG test - start
16:37:26.224 [t3] DEBUG test - z
16:37:27.224 [t1] DEBUG test - x
16:37:27.224 [t2] DEBUG test - y

第二次执行

16:38:51.772 [t3] DEBUG test - start
16:38:51.772 [t2] DEBUG test - start
16:38:51.772 [t1] DEBUG test - start
16:38:51.777 [t3] DEBUG test - z
16:38:51.777 [t2] DEBUG test - y
16:38:52.777 [t1] DEBUG test - x

第三次执行

16:39:40.283 [t2] DEBUG test - start
16:39:40.283 [t1] DEBUG test - start
16:39:40.283 [t3] DEBUG test - start
16:39:40.287 [t2] DEBUG test - y
16:39:40.287 [t3] DEBUG test - z
16:39:41.288 [t1] DEBUG test - x

三个线程几乎同时启动，由于 x和y方法使用了synchronized 关键字加锁，所以 x和y的打印始终是间隔1秒，而z没有加synchronized关键字进行加锁，所以打印肯定不会超过1秒

 

2、synchronized 对两个对象进行加锁

新增一个类

@Slf4j(topic = "test")
public class BasicLock1 {

    public synchronized static void x(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("x");
    }

    public synchronized void y(){
        log.debug("y");
    }

    public void z(){
        log.debug("z");
    }
}

测试类

@Slf4j(topic = "test")
public class TestBasic3 {
    public static void main(String[] args) {
        BasicLock basicLock = new BasicLock();
        BasicLock basicLock1 = new BasicLock();

        new Thread(()->{
            log.debug("start");
            basicLock.x();
        },"t1").start();

        new Thread(()->{
            log.debug("start");
            basicLock1.y();
        },"t2").start();


    }
}

测试类中 进行加锁的是两个对象，所以两个线程的执行互不影响

打印如下

16:51:59.416 [t2] DEBUG test - start
16:51:59.416 [t1] DEBUG test - start
16:51:59.421 [t2] DEBUG test - y
16:52:00.422 [t1] DEBUG test - x

3、synchronized 对静态方法加锁和对普通方法加锁的区别

测试类(锁对象继续使用上文中的 BasicLock1)

@Slf4j(topic = "test")
public class TestBasic4 {
    public static void main(String[] args) {
        BasicLock1 basicLock1 = new BasicLock1();


        new Thread(()->{
            log.debug("start");

            basicLock1.x();
        },"t1").start();

        new Thread(()->{
            log.debug("start");

            basicLock1.y();
        },"t2").start();


    }
}

打印结果

16:53:03.465 [t1] DEBUG test - start
16:53:03.465 [t2] DEBUG test - start
16:53:03.469 [t2] DEBUG test - y
16:53:04.470 [t1] DEBUG test - x

4、synchronized 对同一个类的不同的静态方法加锁

@Slf4j(topic = "test")
public class BasicLock2 {

    public synchronized static void x(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("x");
    }


    public synchronized static void y(){
        log.debug("y");
    }

    public void z(){
        log.debug("z");
    }
}

测试类

@Slf4j(topic = "test")
public class TestBasic5 {
    public static void main(String[] args) {
        BasicLock2 basicLock2 = new BasicLock2();

        new Thread(()->{
            log.debug("start");
            basicLock2.x();
        },"t1").start();

        new Thread(()->{
            log.debug("start");
            basicLock2.y();
        },"t2").start();


    }
}

打印如下

16:56:27.380 [t2] DEBUG test - start
16:56:27.380 [t1] DEBUG test - start
16:56:27.384 [t2] DEBUG test - y
16:56:28.385 [t1] DEBUG test - x

或

16:56:40.872 [t1] DEBUG test - start
16:56:40.872 [t2] DEBUG test - start
16:56:41.875 [t1] DEBUG test - x
16:56:41.875 [t2] DEBUG test - y

总结如下

1、

/**
 * synchronized关键字
 * synchronized关键字锁定的是对象不是代码块,demo中锁的是object对象的实例
 * 锁定的对象有两种:1.类的实例 2.类对象(类锁)
 * 加synchronized关键字之后不一定能实现线程安全，具体还要看锁定的对象是否唯一。
 */
@Slf4j(topic = "test")
public class Demo1 {

    private int count = 10;
    private Object object = new Object();

    public void test(){
        synchronized (object){
            count--;
            log.debug(Thread.currentThread().getName() + " count = " + count);
        }
    }

}

2、

@Slf4j(topic = "test")
public class Demo2 {

    private int count = 10;

    public  void test(){
        //synchronized(this)锁定的是当前类的实例,这里锁定的是Demo2类的实例
        synchronized (this){
            count--;
            log.debug(Thread.currentThread().getName() + " count = " + count);
        }
    }

}

3、

@Slf4j(topic = "test")
public class Demo3 {

    private int count = 10;

    //直接加在方法声明上，相当于是synchronized(this)
    public synchronized void test(){
        count--;
        log.debug(Thread.currentThread().getName() + " count = " + count);
    }

}

4、

@Slf4j(topic = "test")
public class Demo4 {

    private static int count = 10;

    //synchronize关键字修饰静态方法锁定的是类的对象
    public synchronized static void test(){
        count--;
        log.debug(Thread.currentThread().getName() + " count = " + count);
    }

    public static void test2(){
        synchronized (Demo4.class){//这里不能替换成this
            count--;
        }
    }

}
synchronized 关键字使用应注意的地方

1、

**
 * 锁对象的改变
 * 锁定某对象o，如果o的属性发生改变，不影响锁的使用
 * 但是如果o变成另外一个对象，则锁定的对象发生改变
 * 应该避免将锁定对象的引用变成另外一个对象
 */
@Slf4j(topic = "test")
public class Demo1 {

    Object o = new Object();

    public void test(){
        synchronized (o) {
            //t1 在这里无线执行
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        Demo1 demo = new Demo1();

        new Thread(demo :: test, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(demo :: test, "t2");

        demo.o = new Object();
        //t2能否执行？
        t2.start();
    }

}

2、

/**
 * 不要以字符串常量作为锁定的对象
 *
 */
@Slf4j(topic = "enjoy")
public class Demo2 {

    String s1 = "hello";

    String s2 = "hello";

    public void test1(){
        synchronized (s1) {
           log.debug("t1 start...");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("t1 end...");
        }
    }

    public void test2(){
        synchronized (s2) {
            log.debug("t2 start...");
        }
    }

    public static void main(String[] args) {
        Demo2 demo = new Demo2();
        //啓動t1
        new Thread(demo :: test1,"t1").start();
        //启动t2
        new Thread(demo :: test2,"t2").start();
    }

}

3、

/**
 * 同步代码快中的语句越少越好
 * 比较test1和test2
 * 业务逻辑中只有count++这句需要sync，这时不应该给整个方法上锁
 * 采用细粒度的锁，可以使线程争用时间变短，从而提高效率
 */
@Slf4j(topic = "enjoy")
public class Demo3 {

    int count = 0;

    public synchronized void test1(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        count ++;

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    /**
     * 局部加锁
     */
    public void test2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        synchronized (this) {
            count ++;
        }

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

 

 

 

 

这是我的昵称。。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized 的应用
zhaoyunfei1的博客
05-18 363
synchronized 有三种方式来加锁 1. 修饰实例方法，作用于当前实例加锁，进入同步代码前 要获得当前实例的锁 2. 静态方法，作用于当前类对象加锁，进入同步代码前要 获得当前类对象的锁 3. 修饰代码块，指定加锁对象，对给定对象加锁，进入同 步代码库前要获得给定对象的锁。 不同的修饰类型，代表锁的控制粒度 思考锁是如何存储的 可以思考一下，要实现多线程的互斥特性，那这把锁需要 哪些因素？ 1. 锁需要有一个东西来表示，比如获得锁是什么状态、无 锁状态是什么状态 2. 这个状态需要对.
synchronized
m0_51247668的博客
11-22 107
synchronized 实现 对象模型总结： 每一个Java类，在被JVM加载的时候，JVM会给这个类创建一个instanceKlass，保存在方法区，用来在JVM层表示该Java类。当我们在Java代码中，使用new创建一个对象的时候，JVM会创建一个instanceOopDesc对象，这个对象中包含了两部分信息，对象头以及元数据。对象头中有一些运行时数据，其中就包括和多线程相关的锁的信息。元数据其实维护的是指针，指向的是对象所属的类的instanceKlass 每一个Java类，在被JVM加载的时候
同步(同步代码块synchronized(this) 同步方法 、全局锁、同步处理方法对比）
sophia__yu的博客
11-13 6799
class MythreadB implements Runnable { private Integer tickets=10; public void run() { while(tickets>0) { try { System.out.println(Thread.currentThre...
IDEA在多线程环境下断点调试-验证synchronized监视锁的运行状态
最新发布
BADAO_LIUMANG_QIZHI的博客
10-27 823
上面简单介绍synchronized的使用，如果在IDEA中怎样对多线程的程序进行调试，比如分别对单个线程进行断点调试，当第一个线程执行到synchronized时验证是否会上锁，然后再调试另一个线程，是否还能再进入。注：博客：关注公众号霸道的程序猿获取编程相关电子书、教程推送与免费下载。
Java中synchronized 修饰在 static方法和 非static方法的区别
u014732103的博客
05-21 219
Java中synchronized是用来表示同步的，synchronized可以用来修饰一个方法（static方法和非static方法），也可以用来修饰一段代码块； 看代码： public synchronized void x() throws InterruptedException { for (int i = 0; i < 5; i++) { ...
Synchronized详解
机器不学习
04-25 895
Java 同步关键字（synchronized）Java 中的同步块用 synchronized 标记。同步块在 Java 中是同步在某个对象上。所有同步在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞，直到执行该同步块中的线程退出。有四种不同的同步块： 实例方法 静态方法 实例方法中的同步块 静态方法中的同步块 上述同步块都同步在不同对象上。
Java锁Synchronized对象锁和类锁区别
liyongshun82的博客
05-24 548
java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，如果B线程不...
Java synchronized使用案例
01-16
在`Synchronized`压缩包中，可能包含了通过实验来演示`synchronized`关键字使用的一些Java代码。例如，创建一个共享资源类，然后通过多个线程去操作这个资源，使用`synchronized`关键字来保证线程安全。实验可能涉及...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
解决Maven 项目报错 java.httpservlet和synchronized使用方法
08-30
解决Maven项目报错java.httpservlet和synchronized使用方法 在Maven项目中，我们经常会遇到一些报错问题，例如java.httpservlet和synchronized使用方法等。这篇文章将为大家带来解决Maven项目报错java.httpservlet...
Java Synchronized的使用详解
08-18
Java Synchronized的使用详解 Java Synchronized是Java编程语言中的一种同步机制，用于解决并发编程中的线程安全问题。下面是对Java Synchronized的使用详解的知识点总结： 1. 为什么要使用Synchronized？ 在并发...
java中synchronized的使用
10-16
java中synchronized的使用,java中的锁锁的到底是什么？是括号里的代码块吗？肯定不是的；
synchronized方法和代码块
weixin_43808717的博客
10-23 2458
同步 由于多线程并发存在数据不安全问题，为了保证数据的安全性需要一些特殊的手段来维持。数据不安全主要是针对修改来说的，如果一个数据只能读不能修改几乎不会产生什么安全问题。只有修改数据的时候容易产生一些差错导致多线程并发造成数据不安全。 从操作系统的角度来看多线程访问临界资源时并且对临界资源做一定的修改就会产生错误，操作系统为了保证临界资源的安全性，保证每次访问临界资源的线程有且只有一个。多线程访问时会进入等待队列依次排队等待。 Java多线程并发出现数据不安全问题的原因也大致相同，因为某些操作不是原
sychornized
热门推荐
qq_42001445的博客
08-30 1万+
sychornized的应用： 1、加在方法前面； 我们new的这个对象，这个对象调用这个加了sychornized方法，那么这个对象的锁就被这个方法获取了；(System.out.print()这个方法千万不要在实际应用中写，其底层是单例模式，且是同步代码块可想而知所有的System.out.print()用的都是同一个对象的锁，非常影响性能) 2、加在静态方法前面； 静态方法是加sychornized，作用的是class本身，相当于类锁，这个类的所有加了sychornized的静态方法公用一个类锁，所以
synchronized(this)与synchronized(class) 简单实例
雪梦科技
07-11 3092
参考：http://www.cnblogs.com/highriver/archive/2011/12/18/2291965.html 通过对以上文章的拜读，我进一步加深了对线程同步锁的理解。 下面就根据自己的理解，进行的简单实例操作演示。 在看下面的代码前，强烈建议先拜读上面的文章。 源码下载：http://download.csdn.net/detail/yang_hui198
synchronized详解
石芽的专栏
06-22 168
       在并发编程中，当存在共享数据(也称临界资源)和多条线程共同操作共享数据时，会出现线程安全的问题。为了保证多个线程在操作共享数据时，同一时刻有且只有一个线程可以进行操作，其他线程必须等到该线程处理完数据后再进行，java中对对象和类的操作可以使用synchronized：1）java对象锁是用于对象实例（instance）方法，或者一个对象实例上的，2）类锁是用于类的静态方法或者一个类...
java多线程 卖车票
qq_45924373的博客
11-14 217
java 多线程问题 卖车票 如果创建一个类继承Thread线程则只能这样写 package lesson; public class ThreadDemo { public static void main(String[] args) { // TODO Auto-generated method stub Ticket1 t1 = new Ticket1(); Ticket1 t2 = new Ticket1(); Ticket1 t3 = new Ticket1(); Ti
synchronized的介绍，使用和原理
迷雾总会解
01-07 767
synchronized实际上利用对象保证了临界区代码的原子性，临界区内的代码在外界看来是不可分割的，不会被线程切换所打断。
ReentrantLock---基本用法
qq_31391225的博客
09-23 2384
ReentrantLock 特点 1、可打断、可重入 2、可以设置超时时间 3、可以设置为公平锁(默认为非公平锁) 4、支持多个条件标量 使用 1、基本语法 ReentrantLock lock = new ReentrantLock(); //获取锁 lock.lock(); try { //临界区 }finally { //释放锁 lock.unlock(); } 2、重入 ReentrantLock lock = new ReentrantLock();

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值