13518219792
Java的同步可以用synchronized关键字来实现。\x0d\x0a \x0d\x0asychronized可以同步代码，需要绑定一个对象，如synchronized(obj){}\x0d\x0a也可以同步一个方法，是对方法进行线程同步。如public void synchronized methodA(){}
成都创新互联公司2013年成立，先为深圳等服务建站，深圳等地企业，进行企业商务咨询服务。为深圳企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。
要想解决 脏数据 的问题 最简单的方法就是使用synchronized关键字来使run方法同步 代码如下
public synchronized void run(){ }
从上面的代码可以看出 只要在void和public之间加上synchronized关键字 就可以使run方法同步 也就是说 对于同一个Java类的对象实例 run方法同时只能被一个线程调用 并当前的run执行完后 才能被其他的线程调用 即使当前线程执行到了run方法中的yield方法 也只是暂停了一下 由于其他线程无法执行run方法 因此 最终还是会由当前的线程来继续执行 先看看下面的代码
sychronized关键字只和一个对象实例绑定
class Test { public synchronized void method() { } } public class Sync implements Runnable { private Test test; public void run() { thod(); } public Sync(Test test) { this test = test; } public static void main(String[] args) throws Exception { Test test = new Test(); Test test = new Test(); Sync sync = new Sync(test ); Sync sync = new Sync(test ); new Thread(sync ) start(); new Thread(sync ) start(); } }
在Test类中的method方法是同步的 但上面的代码建立了两个Test类的实例 因此 test 和test 的method方法是分别执行的 要想让method同步 必须在建立Sync类的实例时向它的构造方法中传入同一个Test类的实例 如下面的代码所示
Sync sync = new Sync(test );
不仅可以使用synchronized来同步非静态方法 也可以使用synchronized来同步静态方法 如可以按如下方式来定义method方法
class Test { public static synchronized void method() { }}
建立Test类的对象实例如下
Test test = new Test();
对于静态方法来说 只要加上了synchronized关键字 这个方法就是同步的 无论是使用thod（） 还是使用thod（）来调用method方法 method都是同步的 并不存在非静态方法的多个实例的问题
在 种设计模式中的单件（Singleton）模式如果按传统的方法设计 也是线程不安全的 下面的代码是一个线程不安全的单件模式
package test;// 线程安全的Singleton模式class Singleton{ private static Singleton sample; private Singleton() { } public static Singleton getInstance() { if (sample == null) { Thread yield(); // 为了放大Singleton模式的线程不安全性 sample = new Singleton(); } return sample; }}public class MyThread extends Thread{ public void run() { Singleton singleton = Singleton getInstance(); System out println(singleton hashCode()); } public static void main(String[] args) { Thread threads[] = new Thread[ ]; for (int i = ; i threads length; i++) threads[i] = new MyThread(); for (int i = ; i threads length; i++) threads[i] start(); }}
在上面的代码调用yield方法是为了使单件模式的线程不安全性表现出来 如果将这行去掉 上面的实现仍然是线程不安全的 只是出现的可能性小得多
程序的运行结果如下
上面的运行结果可能在不同的运行环境上有所有同 但一般这五行输出不会完全相同 从这个输出结果可以看出 通过getInstance方法得到的对象实例是五个 而不是我们期望的一个 这是因为当一个线程执行了Thread yield（）后 就将CPU资源交给了另外一个线程 由于在线程之间切换时并未执行到创建Singleton对象实例的语句 因此 这几个线程都通过了if判断 所以 就会产生了建立五个对象实例的情况（可能创建的是四个或三个对象实例 这取决于有多少个线程在创建Singleton对象之前通过了if判断 每次运行时可能结果会不一样）
要想使上面的单件模式变成线程安全的 只要为getInstance加上synchronized关键字即可 代码如下
public static synchronized Singleton getInstance() { }
当然 还有更简单的方法 就是在定义Singleton变量时就建立Singleton对象 代码如下
private static final Singleton sample = new Singleton();
然后在getInstance方法中直接将sample返回即可 这种方式虽然简单 但不知在getInstance方法中创建Singleton对象灵活 读者可以根据具体的需求选择使用不同的方法来实现单件模式
在使用synchronized关键字时有以下四点需要注意
synchronized关键字不能继承
虽然可以使用synchronized来定义方法 但synchronized并不属于方法定义的一部分 因此 synchronized关键字不能被继承 如果在父类中的某个方法使用了synchronized关键字 而在子类中覆盖了这个方法 在子类中的这个方法默认情况下并不是同步的 而必须显式地在子类的这个方法中加上synchronized关键字才可以 当然 还可以在子类方法中调用父类中相应的方法 这样虽然子类中的方法不是同步的 但子类调用了父类的同步方法 因此 子类的方法也就相当于同步了 这两种方式的例子代码如下
在子类方法中加上synchronized关键字
class Parent{ public synchronized void method() { }}class Child extends Parent{ public synchronized void method() { }}
在子类方法中调用父类的同步方法
class Parent{ public synchronized void method() { }}class Child extends Parent{ public void method() { thod(); }}
在定义接口方法时不能使用synchronized关键字
构造方法不能使用synchronized关键字 但可以使用下节要讨论的synchronized块来进行同步
synchronized可以自由放置
在前面的例子中使用都是将synchronized关键字放在方法的返回类型前面 但这并不是synchronized可放置唯一位置 在非静态方法中 synchronized还可以放在方法定义的最前面 在静态方法中 synchronized可以放在static的前面 代码如下
public synchronized void method();synchronized public void method();public static synchronized void method();public synchronized static void method();synchronized public static void method();
但要注意 synchronized不能放在方法返回类型的后面 如下面的代码是错误的
public void synchronized method();public static void synchronized method();
synchronized关键字只能用来同步方法 不能用来同步类变量 如下面的代码也是错误的
public synchronized int n = ;public static synchronized int n = ;
虽然使用synchronized关键字同步方法是最安全的同步方式 但大量使用synchronized关键字会造成不必要的资源消耗以及性能损失 虽然从表面上看synchronized锁定的是一个方法 但实际上synchronized锁定的是一个类 也就是说 如果在非静态方法method 和method 定义时都使用了synchronized 在method 未执行完之前 method 是不能执行的 静态方法和非静态方法的情况类似 但静态和非静态方法不会互相影响 看看如下的代码
package test;public class MyThread extends Thread{ public String methodName; public static void method(String s) { System out println(s); while (true) ; } public synchronized void method () { method( 非静态的method 方法 ); } public synchronized void method () { method( 非静态的method 方法 ); } public static synchronized void method () { method( 静态的method 方法 ); } public static synchronized void method () { method( 静态的method 方法 ); } public void run() { try { getClass() getMethod(methodName) invoke(this); } catch (Exception e) { } } public static void main(String[] args) throws Exception { MyThread myThread = new MyThread (); for (int i = ; i = ; i++) { thodName = method + String valueOf(i); new Thread(myThread ) start(); sleep( ); } }}
运行结果如下
非静态的method 方法静态的method 方法
lishixinzhi/Article/program/Java/gj/201311/27526
一般有两种方法同步方法和同步代码块
假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。
1．把synchronized当作函数修饰符时，示例代码如下：
PublicsynchronizedvoidmethodAAA()
{
//….
}
这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。
上边的示例代码等同于如下代码：
publicvoidmethodAAA()
{
synchronized(this)//(1)
{
//…..
}
}
(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于objectreference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（
2．同步块，示例代码如下：
publicvoidmethod3(SomeObjectso)
{
synchronized(so)
{
//…..
}
}
这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：
classFooimplementsRunnable
{
privatebyte[]lock=newbyte[0];//特殊的instance变量
PublicvoidmethodA()
{
synchronized(lock){//…}
}
//…..
}
注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Objectlock=newObject()则需要7行操作码。
3．将synchronized作用于static函数，示例代码如下：
ClassFoo
{
publicsynchronizedstaticvoidmethodAAA()//同步的static函数
{
//….
}
publicvoidmethodBBB()
{
synchronized(Foo.class)//classliteral(类名称字面常量)
}
}
代码中的methodBBB()方法是把classliteral作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
记得在《EffectiveJava》一书中看到过将Foo.class和P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。
可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。
synchronized关键字有两种用法 第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中 另外一种就是synchronized块 我们不仅可以通过synchronized块来同步一个对象变量 也可以使用synchronized块来同步类中的静态方法和非静态方法
synchronized块的语法如下
public void method()
{
… …
synchronized(表达式)
{
… …
}
}
一 非静态类方法的同步
从《使用Synchronized关键字同步类方法》一文中我们知道使用synchronized关键字来定义方法就会锁定类中所有使用synchronzied关键字定义的静态方法或非静态方法 但这并不好理解 而如果使用synchronized块来达到同样的效果 就不难理解为什么会产生这种效果了 如果想使用synchronized块来锁定类中所有的同步非静态方法 需要使用this做为synchronized块的参数传入synchronized块国 代码如下
通过synchronized块同步非静态方法
public class SyncBlock
{
public void method ()
{
synchronized(this) // 相当于对method 方法使用synchronized关键字
{
… …
}
}
public void method ()
{
synchronized(this) // 相当于对method 方法使用synchronized关键字
{
… …
}
}
public synchronized void method ()
{
… …
}
}
在上面的代码中的method 和method 方法中使用了synchronized块 而第 行的method 方法仍然使用synchronized关键字来定义方法 在使用同一个SyncBlock类实例时 这三个方法只要有一个正在执行 其他两个方法就会因未获得同步锁而被阻塞 在使用synchronized块时要想达到和synchronized关键字同样的效果 必须将所有的代码都写在synchronized块中 否则 将无法使当前方法中的所有代码和其他的方法同步
除了使用this做为synchronized块的参数外 还可以使用SyncBlock this作为synchronized块的参数来达到同样的效果
在内类（InnerClass）的方法中使用synchronized块来时 this只表示内类 和外类(OuterClass)没有关系 但内类的非静态方法可以和外类的非静态方法同步 如在内类InnerClass中加一个method 方法 并使method 方法和SyncBlock的三个方法同步 代码如下
使内类的非静态方法和外类的非静态方法同步
public class SyncBlock
{
… …
class InnerClass
{
public void method ()
{
synchronized(SyncBlock this)
{
… …
}
}
}
… …
}
在上面SyncBlock类的新版本中 InnerClass类的method 方法和SyncBlock类的其他三个方法同步 因此 method method method 和method 四个方法在同一时间只能有一个方法执行
Synchronized块不管是正常执行完 还是因为程序出错而异常退出synchronized块 当前的synchronized块所持有的同步锁都会自动释放 因此 在使用synchronized块时不必担心同步锁的释放问题
二 静态类方法的同步
由于在调用静态方法时 对象实例不一定被创建 因此 就不能使用this来同步静态方法 而必须使用Class对象来同步静态方法 代码如下
通过synchronized块同步静态方法
public class StaticSyncBlock
{
public static void method ()
{
synchronized(StaticSyncBlock class)
{
… …
}
}
public static synchronized void method ()
{
… …
}
}
在同步静态方法时可以使用类的静态字段class来得到Class对象 在上例中method 和method 方法同时只能有一个方法执行 除了使用class字段得到Class对象外 还可以使用实例的getClass方法来得到Class对象 上例中的代码可以修改如下
使用getClass方法得到Class对象
public class StaticSyncBlock
{
public static StaticSyncBlock instance;
public StaticSyncBlock()
{
instance = this;
}
public static void method ()
{
synchronized(instance getClass())
{
}
}
}
在上面代码中通过一个public的静态instance得到一个StaticSyncBlock类的实例 并通过这个实例的getClass方法得到了Class对象（一个类的所有实例通过getClass方法得到的都是同一个Class对象 因此 调用任何一个实例的getClass方法都可以） 我们还可以通过Class对象使不同类的静态方法同步 如Test类的静态方法method和StaticSyncBlock类的两个静态方法同步 代码如下
Test类的method方法和StaticSyncBlock类的method method 方法同步
public class Test
{
public static void method()
{
synchronized(StaticSyncBlock class)
{
}
}
}
lishixinzhi/Article/program/Java/gj/201311/27374
