首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >再聊Java 之synchronized

再聊Java 之synchronized

作者头像
田维常
发布2019-09-08 14:19:18
3010
发布2019-09-08 14:19:18
举报

本文面向人群:初中级开发人员

主要内容:

  • synchronized的介绍
  • 使用方式
  • 代码证明synchronized的四大方式

Java synchronized块将方法或代码块标记为已同步。Java synchronized块可用于避免竞争条件。

Java同步关键字

Java中的同步块用synchronized关键字标记。Java中的同步块在某个对象上同步。在同一对象上同步的所有同步块只能同时在其中执行一个线程。尝试进入同步块的所有其他线程都被阻塞,直到同步块内的线程退出块。

synchronized关键字可用于标记四种不同类型的块:

  1. 实例方法
  2. 静态方法
  3. 实例方法中的代码块
  4. 静态方法中的代码块

这些块在不同对象上同步。您需要哪种类型的同步块取决于具体情况。

同步实例方法

这是一个同步的实例方法:

  public synchronized void add(int value){
      this.count + = value;
  }

请注意synchronized在方法声明中使用关键字。这告诉Java该方法是同步的。

Java中的同步实例方法在拥有该方法的实例(对象)上同步。因此,每个实例的同步方法在不同的对象上同步:拥有实例。只有一个线程可以在同步实例方法中执行。如果存在多个实例,则一次一个线程可以在每个实例的同步实例方法内执行。每个实例一个线程。也可以理解为多个对象多把锁。

同步静态方法

静态方法被标记为已同步,就像使用synchronized关键字的实例方法一样。这是一个Java synchronized静态方法示例:

  public static synchronized void add(int value){
      count + = value;
  }

此处synchronized关键字告诉Java该方法是同步的。

同步静态方法在同步静态方法所属的类的类对象上同步。由于每个类在Java VM中只存在一个类对象,因此在同一个类中的静态同步方法中只能执行一个线程。

如果静态同步方法位于不同的类中,则一个线程可以在每个类的静态同步方法内执行。每个类一个线程,无论它调用哪个静态同步方法。

实例方法中的同步块

您不必同步整个方法。有时最好只同步方法的一部分。方法中的Java同步块使这成为可能。

这是一个非同步Java方法中的同步Java代码块:

  public void add(int value){
    synchronized(this){
       this.count + = value;  
    }
  }

此示例使用Java synchronized块构造将代码块标记为已同步。此代码现在将像执行同步方法一样执行。

请注意Java synchronized块构造如何在括号中获取对象。在示例中,使用“this”,这是调用add方法的实例。由synchronized构造在括号中获取的对象称为监视器对象。据说代码在监视器对象上同步。同步实例方法使用它所属的对象作为监视对象。

只有一个线程可以在同一监视器对象上同步的Java代码块内执行。

以下两个示例在它们被调用的实例上同步。因此,它们在同步方面是等效的:

  public class MyClass {
    public synchronized void log1(String msg1,String msg2){
       log.writeln(msg1);
       log.writeln(msg2);
    }
    public void log2(String msg1,String msg2){
       synchronized(this){
          log.writeln(msg1);
          log.writeln(msg2);
       }
    }
  }

因此,在这个例子中,只有一个线程可以在两个同步块中的任何一个内执行。

如果第二个同步块在不同的对象上同步this,则一次只能在每个方法内执行一个线程。

静态方法中的同步块

以下是与静态方法相同的两个示例。这些方法在方法所属的类的类对象上同步:

  public class MyClass {
    public static synchronized void log1(String msg1,String msg2){
       log.writeln(msg1);
       log.writeln(msg2);
    }
    public static void log2(String msg1,String msg2){
       synchronized(MyClass.class){
          log.writeln(msg1);
          log.writeln(msg2);  
       }
    }
  }

只有一个线程可以同时在这两个方法中的任何一个内执行。

如果第二个同步块在不同的对象上同步MyClass.class,那么一个线程可以同时在每个方法内执行。

Java同步示例

下面是一个示例,它启动2个线程并让它们在同一个Counter实例上调用add方法。一次只有一个线程能够在同一个实例上调用add方法,因为该方法在它所属的实例上是同步的。

  public class Counter{
     long count = 0;
     public synchronized void add(long value){
       this.count + = value;
     }
  }
  public class CounterThread extends Thread {
     protected counter counter = null;
     public CounterThread(Counter counter){
        this.counter = counter;
     }
     public void run(){
       for(int i = 0; i <10; i ++){
           counter.add(ⅰ);
        }
     }
  }
  public class Example{
    public static void main(String [] args){
      Counter counter = new Counter();
      Thread threadA = new CounterThread(counter);
      Thread threadB = new CounterThread(counter);

      threadA.start();
      threadB.start();
    }
  }

创建了两个线程。Counter在构造函数中将相同的实例传递给它们。该Counter.add()方法在实例上同步,因为add方法是实例方法,并标记为synchronized。因此,只有一个线程可以一次调用add()方法。另一个线程将等到第一个线程离开add()方法,然后它才能执行方法本身。

如果两个线程引用了两个单独的Counter实例,那么同时调用add()方法就没有问题。调用将发生在不同的对象上,因此调用的方法也将在不同的对象(拥有该方法的对象)上同步。因此呼叫不会阻止。这是如何看起来:

  public class Example{
    public static void main(String [] args){
       Counter counterA = new Counter();
      Counter counterB = new Counter();
      Thread  threadA = new CounterThread(counterA);
      Thread  threadB = new CounterThread(counterB);

      threadA.start();
      threadB.start();
    }
  }

注意两个线程threadAthreadB如何不再引用相同的计数器实例。他们的两个拥有实例的add方法counterAcounterB同步。呼吁add()counterA将因此不会阻塞调用add()counterB

代码证明synchronized四大使用场景

public class SynchronizedDemo {
    /**
     * 普通同步方法
     * 对个对象多把锁
     * 每个线程new SynchronizedDemo().test();
     */
    public synchronized void test() {
        String name = Thread.currentThread().getName();
        System.out.println(name + "获得锁");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "释放锁");
    }

    /**
     * this同步代码块
     * 对个对象多把锁
     * 每个线程new SynchronizedDemo().test();
     */
    public void testBlockThis() {
        synchronized (this) {
            String name = Thread.currentThread().getName();
            System.out.println(name + "获得锁 this 代码块");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "释放锁  this 代码块");
        }
    }

    /**
     * class 同步代码块
     * 对个对象一把锁,这里的对象时Class对象
     * 每个线程new SynchronizedDemo().test();
     */
    public void testBlockClass() {
        synchronized (SynchronizedDemo.class) {
            String name = Thread.currentThread().getName();
            System.out.println(name + "获得锁 class 代码块");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "释放锁  class 代码块");
        }
    }

    /**
     * 静态同步方法
     * 多个线程只能有一个线程获取锁
     * 每个线程new SynchronizedDemo().test();
     */
    public synchronized static void testStatic() {
        String name = Thread.currentThread().getName();
        System.out.println(name + "获得锁 static 代码块");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "释放锁  static 代码块");
    }
}

测试类:

public class SynchronizedDemoTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
//                    synchronizedDemo.test();
//                    synchronizedDemo.testBlockClass();
//                    synchronizedDemo.testBlockThis();
                    SynchronizedDemo.testStatic();
                }
            });
        }
    }
}

希望大家把这段代码运行一下,感受一下具体含义。不要轻易相信别人说技术是怎么样的,引用一句经典名言:

Talk is cheap. Show me the code.

往期回顾

【文章汇总】Java基础篇

你确定能把main方法解释清楚?

快速掌握JDK常用注解

面试必问hashCode和equal

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2019-09-05,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Java后端技术栈 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • Java同步关键字
  • 同步实例方法
  • 同步静态方法
  • 实例方法中的同步块
  • 静态方法中的同步块
  • Java同步示例
  • 代码证明synchronized四大使用场景
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档