synchronized关键字的作用（二）

引申：
对于这种多个实例，要想实现同步即输出的数字是有序并且按线程先后顺序输出，我们可以增加一个静态变量，对它进行加锁(后面将说明锁定的对象)。

修改目标类：

public class TestThread {
    private static Object lock=new Object(); //必须是静态的。
    public  void execute(){
        <SPAN class=hilite1>synchronized</SPAN>(lock){
            for(int i=0;i<100;i++){
                   System.out.println(i);
               }
           }
       }
}

public class TestThread {
private static Object lock=new Object(); //必须是静态的。
public  void execute(){
synchronized(lock){
for(int i=0;i<100;i++){
System.out.println(i);
}
}
}
}

二、同步代码块

public void method(SomeObject so){
    <SPAN class=hilite1>synchronized</SPAN>(so)
       //…..
       }
}

public void method(SomeObject so){
synchronized(so)
//…..
}
}

锁定一个对象，其实锁定的是该对象的引用（object reference）
谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以按上面的代码写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它必须是一个对象）来充当锁（上面的解决方法就是增加了一个状态锁）。

a、锁定一个对象，它不是静态的

private byte[] lock = new byte[0]; // 特殊的instance变量

private byte[] lock = new byte[0]; // 特殊的instance变量

目标类：

public class TestThread {
    private Object lock=new Object();
    public  void execute(){
        <SPAN class=hilite1>synchronized</SPAN>(lock){  //增加了个锁，锁定了对象lock，在同一个类实例中，是线程安全的，但不同的实例还是不安全的。

因为不同的实例有不同对象锁lock
            for(int i=0;i<100;i++){
                   System.out.println(i);
               }
           }
       }
}

public class TestThread {
private Object lock=new Object();
public  void execute(){
synchronized(lock){  //增加了个锁，锁定了对象lock，在同一个类实例中，是线程安全的，但不同的实例还是不安全的。
因为不同的实例有不同对象锁lock
for(int i=0;i<100;i++){
System.out.println(i);
}
}
}
}

其实上面锁定一个方法，等同于下面的：

public void execute(){
    <SPAN class=hilite1>synchronized</SPAN>(this){   //同步的是当然对象
        for(int i=0;i<100;i++){
               System.out.println(i);
           }
       }
}