同步经常作为断面被引用。断面是指一次只能有一个线程执行它。多个线程同时执行同步代码是有可能的。
这个误解是因为很多程序员认为同步关键字锁住了它所包围的代码。但是实际情况不是这样的。同步加锁的是对象,而不是代码。因此,如果你的类中有一个同步方法,这个方法可以被两个不同的线程同时执行,只要每个线程自己创建一个的该类的实例即可。
参考下面的代码:
classFooextendsThread
{
privateintval;
publicFoo(intv)
{
val=v;
}
publicsynchronizedvoidprintVal(intv)
{
while(true)
System.out.println(v);
}
publicvoidrun()
{
printVal(val);
}
}
classSyncTest
{
publicstaticvoidmain(Stringargs[])
{
Foof1=newFoo(1);
f1.start();
Foof2=newFoo(3);
f2.start();
}
}
运行SyncTest产生的输出是1和3交叉的。如果printVal是断面,你看到的输出只能是1或者只能是3而不能是两者同时出现。程序运行的结果证明两个线程都在并发的执行printVal方法,即使该方法是同步的并且由于是一个无限循环而没有终止。
要实现真正的断面,你必须同步一个全局对象或者对类进行同步。下面的代码给出了一个这样的范例。
classFooextendsThread
{
privateintval;
publicFoo(intv)
{
val=v;
}
publicvoidprintVal(intv)
{
synchronized(Foo.class){
while(true)
System.out.println(v);
}
}
publicvoidrun()
{
printVal(val);
}
}
上面的类不再对个别的类实例同步而是对类进行同步。对于类Foo而言,它只有唯一的类定义,两个线程在相同的锁上同步,因此只有一个线程可以执行printVal方法。
这个代码也可以通过对公共对象加锁。例如给Foo添加一个静态成员。两个方法都可以同步这个对象而达到线程安全。
译者注:
下面笔者给出一个参考实现,给出同步公共对象的两种通常方法:
1、
classFooextendsThread
{
privateintval;
privatestaticObjectlock=newObject();
publicFoo(intv)
{
val=v;
}
publicvoidprintVal(intv)
{
synchronized(lock){
while(true)
System.out.println(v);
}
}
publicvoidrun()
{
printVal(val);
}
}
上面的这个例子比原文给出的例子要好一些,因为原文中的加锁是针对类定义的,一个类只能有一个类定义,而同步的一般原理是应该尽量减小同步的粒度以到达更好的性能。笔者给出的范例的同步粒度比原文的要小。
2、
classFooextendsThread
{
privateStringname;
privateStringval;
publicFoo(Stringname,Stringv)
{
this.name=name;
val=v;
}
publicvoidprintVal()
{
synchronized(val){
while(true)System.out.println(name+val);
}
}
publicvoidrun()
{
printVal();
}
}
publicclassSyncMethodTest
{
publicstaticvoidmain(Stringargs[])
{
Foof1=newFoo("Foo1:","printVal");
f1.start();
Foof2=newFoo("Foo2:","printVal");
f2.start();
}
}
上面这个代码需要进行一些额外的说明,因为JVM有一种优化机制,因为String类型的对象是不可变的,因此当你使用""的形式引用字符串时,如果JVM发现内存已经有一个这样的对象,那么它就使用那个对象而不再生成一个新的String对象,这样是为了减小内存的使用。
上面的main方法其实等同于:
publicstaticvoidmain(Stringargs[])
{
Stringvalue="printVal";
Foof1=newFoo("Foo1:",value);
f1.start();
Foof2=newFoo("Foo2:",value);
f2.start();
}
这个误解是因为很多程序员认为同步关键字锁住了它所包围的代码。但是实际情况不是这样的。同步加锁的是对象,而不是代码。因此,如果你的类中有一个同步方法,这个方法可以被两个不同的线程同时执行,只要每个线程自己创建一个的该类的实例即可。
参考下面的代码:
classFooextendsThread
{
privateintval;
publicFoo(intv)
{
val=v;
}
publicsynchronizedvoidprintVal(intv)
{
while(true)
System.out.println(v);
}
publicvoidrun()
{
printVal(val);
}
}
classSyncTest
{
publicstaticvoidmain(Stringargs[])
{
Foof1=newFoo(1);
f1.start();
Foof2=newFoo(3);
f2.start();
}
}
运行SyncTest产生的输出是1和3交叉的。如果printVal是断面,你看到的输出只能是1或者只能是3而不能是两者同时出现。程序运行的结果证明两个线程都在并发的执行printVal方法,即使该方法是同步的并且由于是一个无限循环而没有终止。
要实现真正的断面,你必须同步一个全局对象或者对类进行同步。下面的代码给出了一个这样的范例。
classFooextendsThread
{
privateintval;
publicFoo(intv)
{
val=v;
}
publicvoidprintVal(intv)
{
synchronized(Foo.class){
while(true)
System.out.println(v);
}
}
publicvoidrun()
{
printVal(val);
}
}
上面的类不再对个别的类实例同步而是对类进行同步。对于类Foo而言,它只有唯一的类定义,两个线程在相同的锁上同步,因此只有一个线程可以执行printVal方法。
这个代码也可以通过对公共对象加锁。例如给Foo添加一个静态成员。两个方法都可以同步这个对象而达到线程安全。
译者注:
下面笔者给出一个参考实现,给出同步公共对象的两种通常方法:
1、
classFooextendsThread
{
privateintval;
privatestaticObjectlock=newObject();
publicFoo(intv)
{
val=v;
}
publicvoidprintVal(intv)
{
synchronized(lock){
while(true)
System.out.println(v);
}
}
publicvoidrun()
{
printVal(val);
}
}
上面的这个例子比原文给出的例子要好一些,因为原文中的加锁是针对类定义的,一个类只能有一个类定义,而同步的一般原理是应该尽量减小同步的粒度以到达更好的性能。笔者给出的范例的同步粒度比原文的要小。
2、
classFooextendsThread
{
privateStringname;
privateStringval;
publicFoo(Stringname,Stringv)
{
this.name=name;
val=v;
}
publicvoidprintVal()
{
synchronized(val){
while(true)System.out.println(name+val);
}
}
publicvoidrun()
{
printVal();
}
}
publicclassSyncMethodTest
{
publicstaticvoidmain(Stringargs[])
{
Foof1=newFoo("Foo1:","printVal");
f1.start();
Foof2=newFoo("Foo2:","printVal");
f2.start();
}
}
上面这个代码需要进行一些额外的说明,因为JVM有一种优化机制,因为String类型的对象是不可变的,因此当你使用""的形式引用字符串时,如果JVM发现内存已经有一个这样的对象,那么它就使用那个对象而不再生成一个新的String对象,这样是为了减小内存的使用。
上面的main方法其实等同于:
publicstaticvoidmain(Stringargs[])
{
Stringvalue="printVal";
Foof1=newFoo("Foo1:",value);
f1.start();
Foof2=newFoo("Foo2:",value);
f2.start();
}
博客主要探讨Java同步机制,纠正了很多程序员认为同步关键字锁住代码的误解,指出同步加锁的是对象。通过代码示例展示多个线程可同时执行同步方法,还给出实现真正断面的方法,如同步全局对象或对类同步,并给出不同同步公共对象的参考实现。
5358

被折叠的 条评论
为什么被折叠?



