阻塞锁，非阻塞锁，自旋锁，互斥锁

 

1.阻塞锁

多个线程同时调用同一个方法的时候，所有线程都被排队处理了。让线程进入阻塞状态进行等待，当获得相应的信号（唤醒，时间） 时，才可以进入线程的准备就绪状态，准备就绪状态的所有线程，通过竞争，进入运行状态。

public class Lock{
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){
           //当其他线程进来，即处于等待阻塞状态    
            wait();
        }
        isLocked = true;
    }
    public synchronized void unlock(){
        isLocked = false;
        notify();
    }
}

但是由于被调用的方法越耗时，线程越多的时候，等待的线程等待的时间也就越长，甚至于几分钟或者几十分钟。对于Web等对反应时间要求很高的系统来说，这是不可行的，因此需要让其非阻塞，可以在没有拿到锁之后马上返回，告诉客户稍后重试。

2.非阻塞锁

  多个线程同时调用一个方法的时候，当某一个线程最先获取到锁，这时其他线程判断没拿到锁，这时就直接返回，只有当最先获取到锁的线程释放，其他线程才能进来，在它释放之前其它线程都会获取失败。

public class Lock{
    private boolean isLocked = false;
    public synchronized boolean lock() throws InterruptedException{
        if(isLocked){
           //当没有拿到锁，立即返回，线程不阻塞
           return false;
        }
        isLocked = true;

       return true;
    }
    public synchronized void unlock(){
        isLocked = false;
    }
}

3.自旋锁和互斥锁

当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。

获取锁的线程一直处于活跃状态，由于一直调用while循环，但是并没有执行任何有效的任务，使用这种锁会造成busy-waiting。

互斥锁也是为了保护共享资源的同步，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁。

//自旋锁
public class Lock{
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){
          sout("继续不断的循环来判断是否可以拿到锁");
        }
        isLocked = true;
    }
    public synchronized void unlock(){
        isLocked = false;
    }
}

//互斥锁
public class Lock{
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){
           //当其他线程进来，直接让其进入等待状态，只有当最先拿到锁的资源，才能继续执行判断是否拿到锁   
            wait();
        }
        isLocked = true;
    }
    public synchronized void unlock(){
        isLocked = false;
        notify();
    }
}