Java synchronized和Lock

Synchronized

1. 将synchronized加在方法上, 即可实现对此方法的同步

public synchronized void deposit(float amt) {
    float tmp = amount;
    tmp += amt;
    try {
        Thread.sleep(1);//模拟其它处理所需要的时间，比如刷新数据库等
    } catch (InterruptedException e) {
        // ignore
    }
    amount = tmp;
}

同步加锁的是对象，而不是代码, 这时候对于方法所属的类, 如果创建两个不同的对象, 依然可以在两个线程里同时执行此方法

2. 要实现真正的方法上同步，你必须同步一个全局对象或者对类进行同步。下面的代码给出了一个这样的范例。

class Foo extends Thread 
{ 
　private int val; 
　public Foo(int v) 
　{ 
　　val = v; 
　} 
　public void printVal(int v) 
　{ 
　　synchronized(Foo.class) { 
　　　while(true)
　　　　System.out.println(v); 
　　} 
　} 
　public void run() 
　{ 
　　printVal(val); 
　} 
}

注意这里synchronized了Foo.class, 不再对个别的类实例同步而是对类进行同步。对于类Foo而言，它只有唯一的类定义，两个线程在相同的锁上同步，因此只有一个线程可以执行printVal方法。

3. 这个代码也可以通过对公共对象加锁。例如给Foo添加一个静态成员。两个方法都可以同步这个对象而达到线程安全。

class Foo extends Thread 
{ 
　private int val;
　private static Object lock=new Object();
　public Foo(int v) 
　{ 
　　val = v; 
　} 
　public void printVal(int v) 
　{ 
　　synchronized(lock) { 
　　　while(true)
　　　　System.out.println(v); 
　　} 
　} 
　public void run() 
　{ 
　　printVal(val); 
　} 
}

上面的这个例子比之前给出的例子要好一些, 因为之前加锁是针对类定义的, 一个类只能有一个类定义, 而同步的一般原理是应该尽量减小同步的粒度以到达更好的性能. 这个范例的同步粒度比之前的要小

===

1. synchronized关键字的作用
a. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
b. 当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
c. 当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
d. 第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
e. 以上规则对其它对象锁同样适用.

2. synchronized关键字的作用域
a. 某个对象实例内，synchronized method(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
b. 某个类的范围，synchronized static method{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用
c. 方法中的某个区块，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象

3. synchronized关键字不能继承，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

===

synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）. 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject) {
//允许访问控制的代码
}
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

lock(), lockInterruptibly()

lock(), 拿不到lock, 线程就一直block, 忽略线程的interrupt
tryLock(), 拿不拿得到都立即返回
带时间限制的tryLock(), 拿不到lock就等一段时间直至超时

lockInterruptibly()

每个线程都有一个中断标志, 这里分两种情况:

1.线程在sleep, wait, join状态, 此时如果别的进程调用此进程的 interrupt() 方法, 此线程会被唤醒并被要求处理InterruptedException.

2.线程在运行中则不会收到提醒, 但是此线程的中断标志会被设置, 可以通过isInterrupted()查看并作出处理

lockInterruptibly()和上面的第一种情况是一样的, 线程在请求lock并被阻塞时, 如果被interrupt, 则此线程会被唤醒并被要求处理InterruptedException, 并且如果线程已经被interrupt, 再使用lockInterruptibly的时候, 此线程也会被要求处理interruptedException

Lock的中断和非中断加锁模式的区别在于: 线程尝试获取锁操作失败后，在等待过程中，如果该线程被其他线程中断了，它是如何响应中断请求的.

lock方法会忽略中断请求，继续获取锁直到成功；而lockInterruptibly则直接抛出中断异常来立即响应中断，由上层调用者处理中断。

lock()适用于锁获取操作不受中断影响的情况，此时可以忽略中断请求正常执行加锁操作，因为该操作仅仅记录了中断状态（通过Thread.currentThread().interrupt()操作，只是恢复了中断状态为true，并没有对中断进行响应)。

如果要求被中断线程不能参与锁的竞争操作，则此时应该使用lockInterruptibly方法，一旦检测到中断请求，立即返回不再参与锁的竞争并且取消锁获取操作(即finally中的cancelAcquire操作)