synchronize的几种用法

最新推荐文章于 2024-08-28 16:39:20 发布
最新推荐文章于 2024-08-28 16:39:20 发布
阅读量2k 收藏 6
点赞数 2
分类专栏： Java并发编程 interview记录 文章标签： synchronize 锁 对象锁 类锁 Java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41911762/article/details/102803868
版权

 

 

1.作用在普通方法上

在这种情况下是对象锁，下面可以看到同一时刻只有一个线程能进入demo对象的increase()方法。要进入synchronized修饰的普通方法，就要获取当前对象(demo)的锁。这种方式仅适用于单例模式。

Demo类：

package sychronize_usage;

public class Demo {
  volatile  int count;


   public synchronized  void increase()
    {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + count++);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

Test类及运行结果：

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo=new Demo();
        Thread t1 =new Thread(()->{
            demo.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo.increase();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:5
t2 count:6
t2 count:7
t2 count:8
t2 count:9
 */

 

即使是不同的两个方法，被synchronize修饰同时也只能有一个线程进入其中一个，因为一个对象只有一把锁。

在Demo类中添加decrease()方法

package sychronize_usage;

public class Demo {
  volatile  int count;
   public synchronized void decrease() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + --count);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

   public synchronized  void increase()
    {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + count++);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

Test类中t1执行increase()方法t2执行decrease()方法，运行结果如下：

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo=new Demo();
        Thread t1 =new Thread(()->{
            demo.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo.decrease();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:4
t2 count:3
t2 count:2
t2 count:1
t2 count:0
 */

 

 

如果这样写，同步就会失效，t1线程进入的是demo1对象的increase（）方法，而t2线程进入的是demo2对象的increase（）方法。这也说明，synchronize作用在普通方法上是对象锁：

Demo类不变，Test类中及运行结果

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo1=new Demo();
        Demo demo2=new Demo();
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo2.increase();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t2 count:0
t1 count:1
t2 count:1
t2 count:2
t1 count:2
t2 count:3
t1 count:3
t1 count:4
t2 count:4
 */

2.作用在静态方法上

作用在静态方法上是类锁，修改Demo类的increase()方法为静态方法，要进入Demo类的increase()方法就要获取Demo类的锁，尽管new了两个对象，demo1和demo2，但是线程依然同步。

 

Demo类

package sychronize_usage;

public class Demo {
    volatile static int count;


    public synchronized static void increase() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + count++);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

 Test类及运行结果：

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo1=new Demo();
        Demo demo2=new Demo();
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo2.increase();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:5
t2 count:6
t2 count:7
t2 count:8
t2 count:9
 */

 即使是两个不同的静态方法，被synchronize修饰同一时刻也只有一个线程进入其中一个方法，因为一个类只有一把锁：

Demo类：

package sychronize_usage;

public class Demo {
    volatile static int count;


    public synchronized static void increase() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + count++);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    public synchronized static void decrease() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + --count);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
}

    }

 Test类及运行结果：

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo1=new Demo();
        Demo demo2=new Demo();
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo2.decrease();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:4
t2 count:3
t2 count:2
t2 count:1
t2 count:0
 */

3.作用在代码块上

作用在代码块上，要指定作用范围synchronize(xxx){}，xxx可以是this（当前对象），也可以是其他对象，要执行代码块中的代码必须获得传入对象的锁。

3.1 synchronize(this)，和修饰普通方法一样是对象锁，如果要同步，就不能new多个实例。

Demo类

package sychronize_usage;

public class Demo {
    volatile static int count;
    
    public void increase() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " count:" + count++);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

 Test类及运行结果

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo1=new Demo();
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo1.increase();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:5
t2 count:6
t2 count:7
t2 count:8
t2 count:9
 */

 

也可以传入其他对象，要进入此代码块，必须获得传入对象的锁。

Demo类

package sychronize_usage;

public class Demo {
    volatile static int count;
    Object object;
public Demo(Object obj){
    object=obj;
}
    public void increase() {
        synchronized (object) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " count:" + count++);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

Test类及运行结果

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Object o=new Object();
        Demo demo1=new Demo(o);
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo1.increase();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:5
t2 count:6
t2 count:7
t2 count:8
t2 count:9
 */

 

3.2  synchronize(Demo.class)，要进入代码块，必须获取该类的锁（每个类只有一个class对象）

new 了两个对象，但是可以看出同时只有一个线程能进入同步代码块。

Demo类

package sychronize_usage;

public class Demo {
    volatile static int count;

    public void increase() {
        synchronized (Demo.class) {//this.getClass()
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " count:" + count++);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
   
}

Test类及运行结果 

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo1=new Demo();
        Demo demo2=new Demo();
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo2.increase();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:5
t2 count:6
t2 count:7
t2 count:8
t2 count:9
 */

总结

对象锁：修饰普通方法、修饰代码块传入的对象为this和其他非class对象。

类锁：修饰静态方法、修饰代码块传入的对象为xxx.class。

补充

1.若锁住的是同一个对象，一个线程在访问对象的同步方法时，另一个线程访问对象的同步代码块也会被阻塞，始终记住一点一个对象只有一把锁。

2.synchronize修饰静态方法和synchronize(xxx.class)其实是一回事，要获取的锁是同一个锁，都是class对象的锁。下面验证

Demo类中increase()中的代码块用synchronize(Demo.class)修饰，decrease()方法改成静态方法并用synchronize修饰

package sychronize_usage;

public class Demo {
    volatile static int count;

    public void increase() {
        synchronized (Demo.class) {//this.getClass()
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " count:" + count++);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    public synchronized  static void decrease() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " count:" + --count);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Test类及运行结果：

package sychronize_usage;

public class Test{

    public static void main(String[] args) {
        Demo demo1=new Demo();
        Demo demo2=new Demo();
        Thread t1 =new Thread(()->{
            demo1.increase();
        },"t1");
        Thread t2 =new Thread(()->{
            demo2.decrease();
        },"t2");

        t1.start();
        t2.start();


    }
}
/*
t1 count:0
t1 count:1
t1 count:2
t1 count:3
t1 count:4
t2 count:4
t2 count:3
t2 count:2
t2 count:1
t2 count:0
 */

3.类锁和对象锁互不干扰。因为他们是不同对象的锁，类锁是class对象锁，对象锁是普通对象的锁。

 

 

qq_41911762
关注
专栏目录
synchronized用法详解
ganmaotong的博客
06-01 2万+
目录1.线程安全问题2.使用同步机制管理共享数据3.synchronized原理概述3.1 同步代码块的实现原理3.2 同步方法的原理4.synchronized的使用4.1同步代码块 4.2同步普通方法4.3同步静态方法5.synchronized的不可中断性与可重入性5.1 不可中断性5.2 可重入性6.使用synchronized的注意事项6.1注意synchronized同步块的粒度 6.2 对 String 加锁 6.3 对Integer、Long、Short等包装类加锁 线程允许程
synchronize的两种用法
热门推荐
qq_43265746的博客
01-04 3万+
一、概念：      1、对象锁           包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定锁对象）      2、类锁           指定synchronize修饰静态的方法或指定锁为class对象 二、用法      1、对象锁           （1）同步代码块 package com.zy.san.synSan; /** * ...
Java线程同步机制
浮生若梦
02-24 283
1、多线程的同步： 1.1、同步机制： 在多线程中，可能有多个线程试图访问一个有限的资源，必须预防这种情况的发生。所以引入了同步机制：在线程使用一个资源时为其加锁，这样其他的线程便不能访问那个资源了，直到解锁后才可以访问。 1.2、共享成员变量的例子： 成员变量与局部变量： 成员变量： 如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作，这多个线程是共享一个...
synchronized详细
最新发布
LiuYong_01的博客
08-28 1278
synchronized是Java中实现线程同步的关键字，用于保护共享资源的访问，确保在多线程环境中同一时间只有一个线程能够访问特定的代码段或方法。它提供了互斥性，可见性和有序性三个基本特征，确保了线程间操作的原子性和数据的一致性。互斥性：当一个线程进入了synchronized代码块或方法时，其他视图进入该同步区域的线程必须等待，直至拥有锁的线程执行完毕并释放锁。这确保了在同一时间只能有一个线程访问共享资源，避免了竞态条件和数据不一致的问题。
synchronize的使用
san_rx的博客
05-06 655
1、synchronize可以修饰限定方法或者代码块 2、 （1）当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 （2）然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中
多线程——synchronize的用法
你不在我都在的博客
04-11 1064
synchronized介绍 因为在开发中会遇到“线程安全”与“非线程安全”相关的技术点，“非线程安全”其实会在对多个线程对同一个对象的实例变量进行并发访问时发生，产生的结果就是“脏读”，也就是取到的数据其实是被更改过的。而“线程安全”就是以获得的实例变量的值是经过同步处理的，不会出现“脏读”的现象。 因此为了解决“非线程安全”的问题就需要使用锁，也就是synchronized，synchroni...
java 多线程的几种实现方法总结
08-29
Java 多线程的几种实现方法总结 Java 多线程是指在同一个程序中可以有多条执行线索同时执行，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行。为了帮助大家更好地理解和掌握 Java 多线程的知识，...
java 线程 synchronize_Java 线程详解（二）synchronize
weixin_34410975的博客
02-24 2396
我是按照《Java多线程编程技术》来学习的，所以这一篇是讲线程安全问题和synchronize关键字，下一篇是volatile关键字。一、线程安全问题1.线程安全和非线程安全线程安全：指多线程操作同一个对象的某方法，修改该类的成员变量时，不会出现“脏读”现象，即实例变量的值是经过同步处理的。非线程安全：指多线程操作同一个对象的某方法，修改该类的成员变量时，可能会出现“脏读”现象，即取到的数据其实是...
Eclipse配置SVN的几种方法及使用详情
08-25
Eclipse配置SVN的几种方法及使用详情 Eclipse配置SVN有多种方法，包括从Eclipse Marketplace下载Subclipse插件、从Install New Software里下载、直接下载subclipse的zip文件等。下面将详细介绍每种方法的操作步骤：...
winscp.exe synchronize local用法
09-11
Synchronize是winscp.exe中的一种命令，用于实现本地文件夹与远程文件夹之间的同步。 该命令用法如下： winscp.com synchronize local [本地路径] [远程路径] [本地路径]：指定需要同步的本地文件夹的路径。 ...
Eclipse安装插件的几种方法
11-28
首先，让我们了解Eclipse安装插件的几种基本方法： 1. **Eclipse Marketplace**：这是最常用的方式，适用于大部分插件。在Eclipse中，选择“Help” -> “Eclipse Marketplace”，然后在搜索框中输入插件名称，如...
synchronized 的 8 种用法，你会几种？
weixin_64051447的博客
08-31 1564
本文将介绍8种同步方法的访问场景，我们来看看这8种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是实践，这些都是多线程场景必须要掌握的场景。本文总结了并用代码实现和验证了各种使用场景，以及各种场景发生的原因和结论。我们分析的理论基础都是关键字的锁对象究竟是谁？多个线程之间竞争的是否是同一把锁？根据这个条件来判断线程是否是安全的。
synchronized 的用法
晓游的专栏
06-02 1252
synchronized 是java中的关键字，同步锁，用于解决多线程安全问题。 有以下几种用法一. 修饰一个代码块， 被修饰的代码块称为同步语句块，其同步的作用范围是大括号{}括起来的代码块，锁住的对象由synchronized 后面的小括号里的内容决定。锁会有同步代码块执行完成时释放.     小括号里的内容有以下几种场景  a、synchronized(this) { 同步代码块 }    ...
Java中synchronize的两种用法
iteye_11359的博客
12-15 359
synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： public synchronized void accessVal(int newVal); synchronized 方法控制对类成员变量的访问...
Synchroniz用法
qq_25622107的博客
02-14 690
1.同一个类的synchronized 锁住的方法，同一时间不能有多个线程同时访问package com.mercurylake.test.tree; import java.util.HashSet; import java.util.Set; import org.apache.commons.lang.StringUtils; import com.sun.swing.internal
synchronized三种使用方式(有图)
半页童话
11-06 2755
什么是线程安全 从图中可以看出线程安全只要包括变量在多个线程之间共享、生命周期内状态可以改变、最后结果和预期一致，就是线程安全的。 Synchronized的三种使用方式 1.普通同步方法(实例方法)锁是当前实例对象,进入同步代码前要获得当前实例的锁 2.静态同步方法,锁是当前类的class对象,进入同步代码前要获得当前类对象的锁 3.同步方法块,锁是括号里面的对象,对给定对象加锁,进入同步代...
synchronized三种使用方式
man_8211的专栏
06-08 3832
前言 在多线程并发编程中Synchronized一直是元老级角色，大家都知道synchronized是重量级锁，但是随着Java SE1.6对Synchronized进行了各种优化之后，有些情况下它并不那么重了，与lock相比性能相差并不是很大，还是比较建议同步的时候优先使用synchronized。 三种使用方式 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静
Synchronized的几种用法
weixin_43543184的博客
12-28 2523
我们都知道Synchronized是线程安全同步用的，大部分程序可能只会用到同步方法上面，其实Synchronized可以用到更多的场合，以下列举几种用法供大家参考。 1，同步普通方法 这个也是我们用得最多的，只要涉及线程安全，上来就给方法来个同步锁。这种方法使用虽然最简单，但是只能作用在单例上面，如果不是单例，同步方法锁将失效。 /** * 用在普通方法 */ private synchro...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值