当前位置: 首页 > 编程笔记 >

Java多线程程序中synchronized修饰方法的使用实例

孙梓
2023-03-14
本文向大家介绍Java多线程程序中synchronized修饰方法的使用实例,包括了Java多线程程序中synchronized修饰方法的使用实例的使用技巧和注意事项,需要的朋友参考一下

在Java 5以前,是用synchronized关键字来实现锁的功能

synchronized关键字可以作为方法的修饰符(同步方法),也可作用于函数内的语句(同步代码块)。

掌握synchronized,关键是要掌握把那个东西作为锁。对于类的非静态方法(成员方法)而言,意味着要取得对象实例的锁;对于类的静态方法(类方法)而言,要取得类的Class对象的锁;对于同步代码块,要指定取得的是哪个对象的锁。同步非静态方法可以视为包含整个方法的synchronized(this) { … }代码块。   

不管是同步代码块还是同步方法,每次只有一个线程可以进入(在同一时刻最多只有一个线程执行该段代码。),如果其他线程试图进入(不管是同一同步块还是不同的同步块),jvm会将它们挂起(放入到等锁池中)。这种结构在并发理论中称为临界区(critical section)。

在jvm内部,为了提高效率,同时运行的每个线程都会有它正在处理的数据的缓存副本,当我们使用synchronzied进行同步的时候,真正被同步的是在不同线程中表示被锁定对象的内存块(副本数据会保持和主内存的同步,现在知道为什么要用同步这个词汇了吧),简单的说就是在同步块或同步方法执行完后,对被锁定的对象做的任何修改要在释放锁之前写回到主内存中;在进入同步块得到锁之后,被锁定对象的数据是从主内存中读出来的,持有锁的线程的数据副本一定和主内存中的数据视图是同步的 。

下面举具体的例子来说明synchronized的各种情况。

synchronized同步方法

首先来看同步方法的例子:

public class SynchronizedTest1 extends Thread 
{ 
  private synchronized void testSynchronizedMethod() 
  { 
    for (int i = 0; i < 10; i++) 
    { 
      System.out.println(Thread.currentThread().getName() 
          + " testSynchronizedMethod:" + i); 
 
      try 
      { 
        Thread.sleep(100); 
      } 
      catch (InterruptedException e) 
      { 
        e.printStackTrace(); 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedMethod(); 
  } 
 
  public static void main(String[] args) 
  { 
 
        SynchronizedTest1 t = new SynchronizedTest1(); 
    t.start(); 
    t.testSynchronizedMethod(); 
  } 
} 

运行该程序输出结果为:

main testSynchronizedMethod:0 
main testSynchronizedMethod:1 
main testSynchronizedMethod:2 
main testSynchronizedMethod:3 
main testSynchronizedMethod:4 
main testSynchronizedMethod:5 
main testSynchronizedMethod:6 
main testSynchronizedMethod:7 
main testSynchronizedMethod:8 
main testSynchronizedMethod:9 
Thread-0 testSynchronizedMethod:0 
Thread-0 testSynchronizedMethod:1 
Thread-0 testSynchronizedMethod:2 
Thread-0 testSynchronizedMethod:3 
Thread-0 testSynchronizedMethod:4 
Thread-0 testSynchronizedMethod:5 
Thread-0 testSynchronizedMethod:6 
Thread-0 testSynchronizedMethod:7 
Thread-0 testSynchronizedMethod:8 
Thread-0 testSynchronizedMethod:9 

可以看到testSynchronizedMethod方法在两个线程之间同步执行。

如果此时将main方法修改为如下所示,则两个线程并不能同步执行,因为此时两个线程的同步监视器不是同一个对象,不能起到同步的作用。

public static void main(String[] args) 
  { 
    Thread t = new SynchronizedTest1(); 
    t.start(); 
     
    Thread t1 = new SynchronizedTest1(); 
    t1.start(); 
  } 

此时输出结果如下所示:

Thread-0 testSynchronizedMethod:0 
Thread-1 testSynchronizedMethod:0 
Thread-0 testSynchronizedMethod:1 
Thread-1 testSynchronizedMethod:1 
Thread-0 testSynchronizedMethod:2 
Thread-1 testSynchronizedMethod:2 
Thread-0 testSynchronizedMethod:3 
Thread-1 testSynchronizedMethod:3 
Thread-0 testSynchronizedMethod:4 
Thread-1 testSynchronizedMethod:4 
Thread-0 testSynchronizedMethod:5 
Thread-1 testSynchronizedMethod:5 
Thread-0 testSynchronizedMethod:6 
Thread-1 testSynchronizedMethod:6 
Thread-0 testSynchronizedMethod:7 
Thread-1 testSynchronizedMethod:7 
Thread-0 testSynchronizedMethod:8 
Thread-1 testSynchronizedMethod:8 
Thread-0 testSynchronizedMethod:9 
Thread-1 testSynchronizedMethod:9 

若想修改后的main方法能够在两个线程之间同步运行,需要将testSynchronizedMethod方法声明为静态方法,这样两个线程的监视器是同一个对象(类对象),能够同步执行。修改后的代码如下所示:

public class SynchronizedTest1 extends Thread 
{ 
  private static synchronized void testSynchronizedMethod() 
  { 
    for (int i = 0; i < 10; i++) 
    { 
      System.out.println(Thread.currentThread().getName() 
          + " testSynchronizedMethod:" + i); 
 
      try 
      { 
        Thread.sleep(100); 
      } 
      catch (InterruptedException e) 
      { 
        e.printStackTrace(); 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedMethod(); 
  } 
 
  public static void main(String[] args) 
  { 
    Thread t = new SynchronizedTest1(); 
    t.start(); 
     
    Thread t1 = new SynchronizedTest1(); 
    t1.start(); 
  } 
} 

输出结果如下:

Thread-0 testSynchronizedMethod:0 
Thread-0 testSynchronizedMethod:1 
Thread-0 testSynchronizedMethod:2 
Thread-0 testSynchronizedMethod:3 
Thread-0 testSynchronizedMethod:4 
Thread-0 testSynchronizedMethod:5 
Thread-0 testSynchronizedMethod:6 
Thread-0 testSynchronizedMethod:7 
Thread-0 testSynchronizedMethod:8 
Thread-0 testSynchronizedMethod:9 
Thread-1 testSynchronizedMethod:0 
Thread-1 testSynchronizedMethod:1 
Thread-1 testSynchronizedMethod:2 
Thread-1 testSynchronizedMethod:3 
Thread-1 testSynchronizedMethod:4 
Thread-1 testSynchronizedMethod:5 
Thread-1 testSynchronizedMethod:6 
Thread-1 testSynchronizedMethod:7 
Thread-1 testSynchronizedMethod:8 
Thread-1 testSynchronizedMethod:9 

同步块的情况与同步方法类似,只是同步块将同步控制的粒度缩小,这样能够更好的发挥多线程并行执行的效率。
使用this对象控制同一对象实例之间的同步:

public class SynchronizedTest2 extends Thread 
{ 
  private void testSynchronizedBlock() 
  { 
    synchronized (this) 
    { 
      for (int i = 0; i < 10; i++) 
      { 
        System.out.println(Thread.currentThread().getName() 
            + " testSynchronizedBlock:" + i); 
 
        try 
        { 
          Thread.sleep(100); 
        } 
        catch (InterruptedException e) 
        { 
          e.printStackTrace(); 
        } 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedBlock(); 
  } 
 
  public static void main(String[] args) 
  { 
    SynchronizedTest2 t = new SynchronizedTest2(); 
    t.start(); 
 
    t.testSynchronizedBlock(); 
  } 
} 

输出结果:

main testSynchronizedBlock:0 
main testSynchronizedBlock:1 
main testSynchronizedBlock:2 
main testSynchronizedBlock:3 
main testSynchronizedBlock:4 
main testSynchronizedBlock:5 
main testSynchronizedBlock:6 
main testSynchronizedBlock:7 
main testSynchronizedBlock:8 
main testSynchronizedBlock:9 
Thread-0 testSynchronizedBlock:0 
Thread-0 testSynchronizedBlock:1 
Thread-0 testSynchronizedBlock:2 
Thread-0 testSynchronizedBlock:3 
Thread-0 testSynchronizedBlock:4 
Thread-0 testSynchronizedBlock:5 
Thread-0 testSynchronizedBlock:6 
Thread-0 testSynchronizedBlock:7 
Thread-0 testSynchronizedBlock:8 
Thread-0 testSynchronizedBlock:9 

使用class对象控制不同实例之间的同步:

public class SynchronizedTest2 extends Thread 
{ 
  private void testSynchronizedBlock() 
  { 
    synchronized (SynchronizedTest2.class) 
    { 
      for (int i = 0; i < 10; i++) 
      { 
        System.out.println(Thread.currentThread().getName() 
            + " testSynchronizedBlock:" + i); 
 
        try 
        { 
          Thread.sleep(100); 
        } 
        catch (InterruptedException e) 
        { 
          e.printStackTrace(); 
        } 
      } 
    } 
  } 
 
  @Override 
  public void run() 
  { 
    testSynchronizedBlock(); 
  } 
 
  public static void main(String[] args) 
  { 
    Thread t = new SynchronizedTest2(); 
    t.start(); 
 
    Thread t2 = new SynchronizedTest2(); 
    t2.start(); 
  } 
} 

输出结果:

Thread-0 testSynchronizedBlock:0 
Thread-0 testSynchronizedBlock:1 
Thread-0 testSynchronizedBlock:2 
Thread-0 testSynchronizedBlock:3 
Thread-0 testSynchronizedBlock:4 
Thread-0 testSynchronizedBlock:5 
Thread-0 testSynchronizedBlock:6 
Thread-0 testSynchronizedBlock:7 
Thread-0 testSynchronizedBlock:8 
Thread-0 testSynchronizedBlock:9 
Thread-1 testSynchronizedBlock:0 
Thread-1 testSynchronizedBlock:1 
Thread-1 testSynchronizedBlock:2 
Thread-1 testSynchronizedBlock:3 
Thread-1 testSynchronizedBlock:4 
Thread-1 testSynchronizedBlock:5 
Thread-1 testSynchronizedBlock:6 
Thread-1 testSynchronizedBlock:7 
Thread-1 testSynchronizedBlock:8 
Thread-1 testSynchronizedBlock:9 

 
使用synchronized关键字进行同步控制时,一定要把握好对象监视器,只有获得监视器的进程可以运行,其它都需要等待获取监视器。任何一个非null的对象都可以作为对象监视器,当synchronized作用在方法上时,锁住的便是对象实例(this);当作用在静态方法时锁住的便是对象对应的Class实例

两个线程同时访问一个对象的同步方法
当两个并发线程访问同一个对象的同步方法时,只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个以后才能执行。

public class TwoThread {
  public static void main(String[] args) {
    final TwoThread twoThread = new TwoThread();

    Thread t1 = new Thread(new Runnable() {
      public void run() {
        twoThread.syncMethod();
      }
    }, "A");
    Thread t2 = new Thread(new Runnable() {
      public void run() {
        twoThread.syncMethod();
      }
    }, "B");

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

  public synchronized void syncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " : " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

输出结果:

A : 0
A : 1
A : 2
A : 3
A : 4
B : 0
B : 1
B : 2
B : 3
B : 4

两个线程访问的是两个对象的同步方法
这种情况下,synchronized不起作用,跟普通的方法一样。因为对应的锁是各自的对象。

public class TwoObject {
  public static void main(String[] args) {
    final TwoObject object1 = new TwoObject();
    Thread t1 = new Thread(new Runnable() {
      public void run() {
        object1.syncMethod();
      }
    }, "Object1");
    t1.start();

    final TwoObject object2 = new TwoObject();
    Thread t2 = new Thread(new Runnable() {
      public void run() {
        object2.syncMethod();
      }
    }, "Object2");
    t2.start();
  }

  public synchronized void syncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " : " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

其中一种可能的输出结果:

Object2 : 0
Object1 : 0
Object1 : 1
Object2 : 1
Object2 : 2
Object1 : 2
Object2 : 3
Object1 : 3
Object1 : 4
Object2 : 4

两个线程访问的是synchronized的静态方法
这种情况,由于锁住的是Class,在任何时候,该静态方法只有一个线程可以执行。

同时访问同步方法与非同步方法
当一个线程访问对象的一个同步方法时,另一个线程仍然可以访问该对象中的非同步方法。

public class SyncAndNoSync {
  public static void main(String[] args) {
    final SyncAndNoSync syncAndNoSync = new SyncAndNoSync();

    Thread t1 = new Thread(new Runnable() {
      public void run() {
        syncAndNoSync.syncMethod();
      }
    }, "A");
    t1.start();

    Thread t2 = new Thread(new Runnable() {
      public void run() {
        syncAndNoSync.noSyncMethod();
      }
    }, "B");
    t2.start();
  }

  public synchronized void syncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at syncMethod(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

  public void noSyncMethod() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at noSyncMethod(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

一种可能的输出结果:

B at noSyncMethod(): 0
A at syncMethod(): 0
B at noSyncMethod(): 1
A at syncMethod(): 1
B at noSyncMethod(): 2
A at syncMethod(): 2
B at noSyncMethod(): 3
A at syncMethod(): 3
A at syncMethod(): 4
B at noSyncMethod(): 4

访问同一个对象的不同同步方法
当一个线程访问一个对象的同步方法A时,其他线程对该对象中所有其它同步方法的访问将被阻塞。因为第一个线程已经获得了对象锁,其他线程得不到锁,则虽然是访问不同的方法,但是没有获得锁,也无法访问。

public class TwoSyncMethod {
  public static void main(String[] args) {
    final TwoSyncMethod twoSyncMethod = new TwoSyncMethod();

    Thread t1 = new Thread(new Runnable() {
      public void run() {
        twoSyncMethod.syncMethod1();
      }
    }, "A");
    t1.start();

    Thread t2 = new Thread(new Runnable() {
      public void run() {
        twoSyncMethod.syncMethod2();
      }
    }, "B");
    t2.start();
  }

  public synchronized void syncMethod1() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at syncMethod1(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

  public synchronized void syncMethod2() {
    for (int i = 0; i < 5; i++) {
      System.out.println(Thread.currentThread().getName() + " at syncMethod2(): " + i);
      try {
        Thread.sleep(500);
      } catch (InterruptedException ie) {
      }
    }
  }

}

输出结果:

A at syncMethod1(): 0
A at syncMethod1(): 1
A at syncMethod1(): 2
A at syncMethod1(): 3
A at syncMethod1(): 4
B at syncMethod2(): 0
B at syncMethod2(): 1
B at syncMethod2(): 2
B at syncMethod2(): 3
B at syncMethod2(): 4
 类似资料:
  • 本文向大家介绍Java使用synchronized修饰方法来同步线程的实例演示,包括了Java使用synchronized修饰方法来同步线程的实例演示的使用技巧和注意事项,需要的朋友参考一下 Java中可以使用关键字synchronized进行线程同步控制,实现关键资源顺序访问,避免由于多线程并发执行导致的数据不一致性等问题。synchronized的原理是对象监视器(锁),只有获取到监视器的线程

  • 本文向大家介绍java多线程编程之Synchronized块同步方法,包括了java多线程编程之Synchronized块同步方法的使用技巧和注意事项,需要的朋友参考一下 文章分享了4个例子对synchronized的详细解释 1、是否加synchronized关键字的不同 加了synchronized关键字的输出结果如下 会先输出一组0-4,接着再输出下一组,两个线程顺序执行 excute:0

  • 本文向大家介绍nodejs中使用多线程编程的方法实例,包括了nodejs中使用多线程编程的方法实例的使用技巧和注意事项,需要的朋友参考一下 在以前的博文别说不可能,nodejs中实现sleep中,我向大家介绍了nodejs addon的用法。今天的主题还是addon,继续挖掘c/c++的能力,弥补nodejs的弱点。 我曾多次提到过nodejs的性能问题。其实就语言本身而言,nodejs的性能还是

  • 本文向大家介绍Java中synchronized关键字修饰方法同步的用法详解,包括了Java中synchronized关键字修饰方法同步的用法详解的使用技巧和注意事项,需要的朋友参考一下 Java的最基本的同步方式,即使用synchronized关键字来控制一个方法的并发访问。 每一个用synchronized关键字声明的方法都是临界区。在Java中,同一个对象的临界区,在同一时间只有一个允许被访

  • 本文向大家介绍Java多线程编程中synchronized关键字的基础用法讲解,包括了Java多线程编程中synchronized关键字的基础用法讲解的使用技巧和注意事项,需要的朋友参考一下 多线程编程中,最关键、最关心的问题应该就是同步问题,这是一个难点,也是核心。 从jdk最早的版本的synchronized、volatile,到jdk 1.5中提供的java.util.concurrent.

  • 本文向大家介绍Java 多线程Synchronized和Lock的区别,包括了Java 多线程Synchronized和Lock的区别的使用技巧和注意事项,需要的朋友参考一下 引言   在多线程中,为了使线程安全,我们经常会使用synchronized和Lock进行代码同步和加锁,但是具体两者有什么区别,什么场景下适合用什么可能还不大清楚,主要的区别大致如下: 区别     1、synchroni