java线程的同步互斥和通讯

一、同步和锁定

1、锁的原理

Java中每个对象都有一个内置锁。

当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。

当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。

一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。

释放锁是指持锁线程退出了synchronized同步方法或代码块。

关于锁和同步，有一下几个要点：

1）、只能同步方法，而不能同步变量和类；

2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

6）、线程睡眠时，它所持的任何锁都不会释放。

7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。

9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：

public int fix(int y) {
synchronized (this) {
x = x - y;
}
return x;
}

当然，同步方法也可以改写为非同步方法，但功能完全一样的，例如：

public synchronized int getX() {
return x++;
}

与

public int getX() {
synchronized (this) {
return x;
}
}

效果是完全一样的。

二、静态方法同步

要同步静态方法，需要一个用于整个类对象的锁，这个对象是就是这个类（XXX.class)。

例如：

public static synchronized int setName(String name){

Xxx.name = name;

}

等价于
public static int setName(String name){
synchronized(Xxx.class){
Xxx.name = name;
}
}

三、经验模式

例1：简单应用

 

Java代码  

1. public class TraditionalThreadSynchronized {  
2.     public static void main(String[] args) {  
3.         new TraditionalThreadSynchronized().init();  
4.     }  
5.     private void init(){  
6.         final Outputer outputer = new Outputer();  
7.         new Thread(new Runnable(){  
8.             @Override  
9.             public void run() {  
10.                 while(true){  
11.                     try {  
12.                         Thread.sleep(10);  
13.                     } catch (InterruptedException e) {  
14.                         e.printStackTrace();  
15.                     }  
16.                     outputer.output("nihaobeijing");  
17.                 }  
18.                   
19.             }  
20.         }).start();  
21.     }  
22.     //内部类  
23.     class Outputer{  
24.         public synchronized void output(String name){  
25.             int len = name.length();  
26.             for(int i=0;i<len;i++){  
27.                     System.out.print(name.charAt(i));  
28.             }  
29.             System.out.println();  
30.         }  
31.     }  
32. }  

 

要用到共同数据（包括同步锁）的若干个方法应该归到同一个类上，这种设计体现了高内聚和程序的健壮性。

原文http://suo.iteye.com/blog/1199685