Java 中synchronize函数的实例详解

java 中synchronize函数的实例详解

java中的一个类的成员函数若用synchronized来修饰，则对应同一个对象，多个线程像调用这个对象的这个同步函数时必须等到上一个线程调用完才能由下一个线程调用。

那么如果一个类同时有两个成员函数是由synchronized修饰如代码所示，对与同一个对象，是否可以在两个线程运行时，一个调用funca，同时另一个调用funcb？

mysyn是这样一个类，如果我有两个线程，一个在run方法中先运行funca再运行funcb，另一个线程在run方法中先运行funcb再运行funca。那有没有可能出现这样的情况：在输出时start a...后面直接输出start b...？

public class mysyn { 
  public synchronized void funca(string str){ 
    system.out.println(str+":"); 
    system.out.println("start a..."); 
    try { 
      thread.sleep(5000); 
    } catch (interruptedexception e) { 
      // todo auto-generated catch block 
      e.printstacktrace(); 
    } 
    system.out.println("...a end"); 
  } 
   
  public synchronized void funcb(string str){ 
    system.out.println(str+":"); 
    system.out.println("start b..."); 
    try { 
      thread.sleep(5000); 
    } catch (interruptedexception e) { 
      // todo auto-generated catch block 
      e.printstacktrace(); 
    } 
    system.out.println("...b end"); 
  } 
} 

测试代码如下：

这个线程是先运行funca的

public class mythread implements runnable { 
 
  private mysyn mysyn; 
  private string id; 
  public mythread(mysyn syn, string id){ 
    this.mysyn = syn; 
    this.id = id; 
  } 
  @override 
  public void run() { 
     
    this.mysyn.funca(id); 
    try { 
      thread.sleep(1000); 
    } catch (interruptedexception e) { 
      // todo auto-generated catch block 
      e.printstacktrace(); 
    } 
    this.mysyn.funcb(id); 
  } 
   
  public static void main(string arg[]){ 
    mysyn syn=new mysyn(); 
    thread t1 = new thread(new mythread(syn, "t1")); 
    thread t2 = new thread(new yourthread(syn, "t2")); 
     
     
    t1.start(); 
    t2.start(); 
  } 
 
} 

这个线程是先运行funcb的

public class yourthread implements runnable { 
 
  private mysyn mysyn; 
  private string id; 
  public yourthread(mysyn syn, string id){ 
    this.mysyn = syn; 
    this.id=id; 
  } 
  @override 
  public void run() { 
    this.mysyn.funcb(id); 
    this.mysyn.funca(id); 
     
 
  } 
 
} 

输出结果多是：

t1: 
start a... 
...a end 
t2: 
start b... 
...b end 
t2: 
start a... 
...a end 
t1: 
start b... 
...b end 

如果取消mythread的run方法中两个函数调用间的sleep，那结果多是：

t1: 
start a... 
...a end 
t1: 
start b... 
...b end 
t2: 
start b... 
...b end 
t2: 
start a... 
...a end 

个人结果可能因线程调度不同，但是永远不会有：start a...后面直接输出start b...

那如果funcb不是一个同步函数，那上述代码运行结果会是怎么样呢？

代码稍加改动，把funcb的synchronized关键字去掉。运行结果为：

t2: 
t1: 
start a... 
start b... 
...a end 
t1: 
start b... 
...b end 
t2: 
start a... 
...b end 
...a end 

显然出现了start a...后面直接输出start b...的结果。

同样如果mysyn类如果有一个public 的成员变量，多线程也可以再同步函数被调用的同时，由另一个线程修改这个成员变量。

上述实验说明了：同步的成员函数只能在同一个对象的同步函数调用中对其他同步函数（包括本身）有排它的效果，即多线程运行中，同一个对象当前只能有一个同步函数在运行，但不排除其他非同步函数的运行或对成员进行访问。

 那现在假设某个类有两个静态同步方法，那情况怎么样呢？

具体实现，我就不重复了，因为结果类似：

在多线程中，同一个类，当前只能有一个类同步函数（静态同步函数）在运行，但不排除其他非同步静态函数的运行或对静态成员的访问

如有疑问请留言或者到本站社区交流讨论，感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！