java编程

1.      使用synchronized关键字 
(1)    同步方法 
修饰对象实例方法 
e.g. 

class A{
private final byte[] INSTANCE_LOCK=new byte[0];
synchronized void instanceMethod(){
}
}
A a1 = new A();
A a2 = new A();
A a3=new A();

当多个线程调用a的方法instanceMethod时，同一时刻只有一个线程能执行 
线程1执行a1. instanceMethod() 
线程2执行a1. instanceMethod() 
线程3执行a2. instanceMethod() 
线程4执行a2. instanceMethod() 
线程5执行a3. instanceMethod() 
线程6执行a3. instanceMethod() 
同一时刻线程1、2只有一个线程能执行a1. instanceMethod() 
同一时刻线程3、4只有一个线程能执行a2. instanceMethod() 
同一时刻线程5、6只有一个线程能执行a3. instanceMethod() 
线程1(或2 )、3(或4)、5(或6)并不同步互斥 

synchronized void instanceMethod(){
}
//等价于
void instanceMethod(){
synchronized(this){
}
}

对象锁为当前的对象实例，如a1,a2,a3等 
也可等价于 

void instanceMethod(){
sysnchronized(INSTANCE_LOCK){
}
}

//修饰类方法(静态方法)
//e.g.
class B{
private static final byte[] CLASS_LOCK=new byte[0];
synchronized static void classMethod(){
}
}

当多个线程调用B的静态方法classMethod()，同一时刻只有一个线程能执行 
例如 
B b1 = new B(); 
B b2 = new B(); 
B b3 = new B(); 
线程1执行b1. classMethod()或B.classMehoth() 
线程2执行b2.classMethod()或B.classMehoth() 
线程3执行b3.classMehtoed()或B.classMehoth() 
同一时刻线程1、2、3只有一个线程能执行B.classMehoth() 

synchronized static void classMethod(){
}
//等价于
void classMethod(){
synchronized (B.class)
}
}

对象锁为当前的对象所属的类 
也等价于 

void classMethon(){
Synchronized(CLASS_LOCK){
}
}

注：获取对象锁之后便可以进入方法或代码块，当方法或代码执行完对象锁自动释放 
(2)    同步代码块 

Object lock;
synchronize(lock){
//……
}

拥有对象锁lock之后便可以进入代码块，代码执行完对象锁lock自动释放 

2.      wait()、notify() 
Object lock; 
1.lock.wait() 释放对象锁，并让当前线程(执行lock.wait()的线程)等待直到另一个线程调用lock.notify() 
2.lock.notify() 唤醒其他线程(执行lock.wait()的线程) 

使用wait()和notify()时，当前线程应该拥有对象锁 
(the owner of this object's monitor) 

synchronized (lock){
// 拥有对象锁进入代码块
// do a
lock.wait(); // 手动释放对象锁(让其他线程可以拥有对象锁),等待直到其他线程通知
// 收到通知后do b
}

synchronized(lock){
//拥有对象锁do c
Lock.notify();// 通知等待线程执行(The awakenedthread will not be able to proceed until the current thread relinquishes thelock on this object)
// 继续do d
// 自动释放对象锁(唤醒的线程可以执行了)
}