java synchronized详解

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

• 1. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
• 2. 当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

3. 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

4. 第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

5. 以上规则对其它对象锁同样适用.

public class Thread1 implements Runnable {  
     public void run() {  
          synchronized(this) {  
               for (int i = 0; i < 5; i++) {  
                    System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);  
               }  
          }  
     }  
     public static void main(String[] args) {  
          Thread1 t1 = new Thread1();  
          Thread ta = new Thread(t1, "A");  
          Thread tb = new Thread(t1, "B");  
          ta.start();  
          tb.start();  
     } 
}

运行结果：

结果： 
     A synchronized loop 0 
     A synchronized loop 1 
     A synchronized loop 2 
     A synchronized loop 3 
     A synchronized loop 4 
     B synchronized loop 0 
     B synchronized loop 1 
     B synchronized loop 2 
     B synchronized loop 3 
     B synchronized loop 4

public class Thread2 {  
     public void m4t1() {  
          synchronized(this) {  
               int i = 5;  
               while( i-- > 0) {  
                    System.out.println(Thread.currentThread().getName() + ":" + i);  
                    try {  
                         Thread.sleep(500);  
                    } catch (InterruptedException ie) {  
                    }  
               }  
          }  
     }  
     public void m4t2() {  
          int i = 5;  
          while( i-- > 0) {  
               System.out.println(Thread.currentThread().getName() + " : " + i);  
               try {  
                    Thread.sleep(500);  
               } catch (InterruptedException ie) {  
               }  
          }  
     }  
     public static void main(String[] args) {  
          final Thread2 myt2 = new Thread2();  
          Thread t1 = new Thread(new Runnable(){public void run(){myt2.m4t1();}}, "t1");  
          Thread t2 = new Thread(new Runnable(){public void run(){myt2.m4t2();}}, "t2");  
          t1.start();  
          t2.start();  
     } 
}

运行结果：

结果： 
     t1 : 4 
     t2 : 4 
     t1 : 3 
     t2 : 3 
     t1 : 2 
     t2 : 2 
     t1 : 1 
     t2 : 1 
     t1 : 0 
     t2 : 0

//修改Thread2.m4t2()方法：  
     public void m4t2() {  
          synchronized(this) {  
               int i = 5;  
               while( i-- > 0) {  
                    System.out.println(Thread.currentThread().getName() + ":" + i);  
                    try {  
                         Thread.sleep(500);  
                    } catch (InterruptedException ie) {  
                    }  
               }  
          }

     }

结果： 
     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

使用对象锁：

public class Foo extends Thread {
    private int val;
    private String name;
    private Object lock; //对象锁
    public Foo(String n,int v, Object l) {
        val = v;
        name = n;
        lock = l;
    }

    public void printVal() throws InterruptedException {
        synchronized (lock) {
            while (val>0){
                Thread.sleep(500);
                System.out.println(name + " " + val);
                val--;
            }
        }
    }

    public void run() {
        try {
            printVal();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String args[]) {
        Object lock = new String("3");
        Foo f1 = new Foo("f1",5, lock);
        f1.start();
        Foo f2 = new Foo("f2",5, 

"3"

);
        f2.start();
    }
}

结果：

f2: 5
f1: 5
f2: 4
f1: 4
f1: 3
f2: 3
f1: 2
f2: 2
f1: 1
f2: 1

如果把锁换成一个对象，如下：

public static void main(String args[]) {
        Foo f1 = new Foo("f1",5, 2);
        f1.start();
        Foo f2 = new Foo("f2",5, 2);
        f2.start();
        long mask = 0xFFL << 8;
        System.out.println(mask);
    }

结果：

f1: 5
f1: 4
f1: 3
f1: 2
f1: 1
f2: 5
f2: 4
f2: 3
f2: 2
f2: 1

 

synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： 
public synchronized void accessVal(int newVal); 
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态。

synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下： 
synchronized(syncObject) { 
//允许访问控制的代码 
} 
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

 

synchronized 方法：可以认为整个方法的内容都放到了synchronized(this) { }块内 

 

有趣的代码如下：

public class Foo extends Thread {
    private int val;
    private String name;
    private Object lock;
    private int val2;
    public void setValues(String n,int v, Object l){
        val = v;
        name = n;
        lock = l;
        val2 = 0 - v;
    }
    private void sleep(){
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public Foo(){
    }
    public Foo(String n,int v, Object l) {
        val = v;
        name = n;
        lock = l;
        val2 = 0 - v;
    }

    public void printVal()  {
        synchronized (lock) {
            while (val>0){
                System.out.println(name + ": " + val);
                val--;
                sleep();
            }
        }
    }
    
    public synchronized void printVal2(){
        while (val2 < 0){
            System.out.println(name + ": " + val2);
            val2++;
            sleep();
        }
    }

    public void run() {
        printVal();
    }

    public static void main(String args[]) {
        final Foo f1 = new Foo();
        f1.setValues("f1",5, f1);
        final Foo f2 = new Foo("f2",5, f1);
        
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                f1.printVal2();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                f2.printVal2();
            }
        });
        f1.start(); // lock = f1
        f2.start(); // lock = f1
        t1.start(); // lock = f1
        t2.start(); // lock = f2
    }
}

输出：

f1: 5
f2: -5
f2: -4
f1: 4
f1: 3
f2: -3
f2: -2
f1: 2
f2: -1
f1: 1
f2: 5
f2: 4
f2: 3
f2: 2
f2: 1
f1: -5
f1: -4
f1: -3
f1: -2
f1: -1