线程同步的方法：Synchronized、Lock、ReentrantLock分析-阿里云开发者社区

Synchronized：

Synchronized修饰的代码块或者方法被某个线程获取到之后，其他线程就会被阻塞。当被修饰的方法执行完后则自动释放锁

Lock：

Lock是一个接口，lock提供比Synchronized更广泛的锁操作，他们允许更灵活的结构化可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

下面列出Lock的常用方法：

void lock():

获得锁

void lockInterruptibly():

获取锁，如果可用则立即返回，如果不可用，则处于休眠。

Condition newCondition();

返回Condition绑定该实例的Lock实例。

Boolean tryLock():

如果可用，则获取锁，并返回true。如果锁不可用，则返回false。

Boolean tryLock(long time, TimeUnit unit)：

如果获取到锁，则立即返回true，否则会等待给定的参数时间，在等待的过程中，获取到返回true，等待超时返回false。

void unlock():

释放锁

注意：当一个线程获取了锁之后，是不会被interrupt()方法中断的，interrupt方法只能中断被阻塞的线程。如果要中断，只能在加锁的方法里面手动实现。

区别：

当使用lockInterruptibly()方法的时候，如果没有获取到锁，则线程进入休眠，但是在休眠的过程中，当前线程可以被其他线程中断（会受到InterruptedException异常），也就是锁有两个线程 A,B,获取锁，B获取到锁了，然后A进行休眠，但是这个时候可以调用A.interrupt()方法中断A的休眠。

当使用synchronized修饰的时候，当一个线程处于等待的时候是不能被中断的。

ReentrantLock：

是可重入锁，ReentrantLock是唯一实现了Lock接口的类，并且提供了更多的使用方法。

ReentrantLock的使用:

请观察如下代码：

public class Demo5 {
  public static void main(String[] args) {
  Demo5 demo = new Demo5();
  new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();
    }
  }).start();
  new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();
    }
  }).start();
  }
  public void Test(){
  Lock lock = new ReentrantLock();
  lock.lock();//获取锁
  try{
    System.out.println(Thread.currentThread().getName()+"获得了锁");
    Thread.sleep(2000);
  }catch(Exception e){
    e.printStackTrace();
  }finally {  
      lock.lock();
    System.out.println(Thread.currentThread().getName()+"释放了锁");
  }
  }
}

结果如下：

Thread-0获得了锁

Thread-1获得了锁

Thread-0释放了锁

Thread-1释放了锁

为什么呢？因为lock是局部变量，每次执行的时候都会创建一个他的对象，所以获取锁的时候获取的就是不同的锁了。

修改的时候只需要将 Lock lock = new ReentrantLock(); 设置为成员变量即可。

tryLock方法的使用：

public class Demo5 {
  Lock lock = new ReentrantLock();
  public static void main(String[] args) {
  Demo5 demo = new Demo5();
  new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();
    }
  }).start();
  new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();
    }
  }).start();
  }
  public void Test(){
  if(lock.tryLock()){
    lock.lock();//获取锁
    try{
    System.out.println(Thread.currentThread().getName()+"获得了锁");
    Thread.sleep(2000);
    }catch(Exception e){
    e.printStackTrace();
    }finally {  
    System.out.println(Thread.currentThread().getName()+"释放了锁");
    lock.unlock();
    }
  }else{
    System.out.println(Thread.currentThread().getName()+"获取锁失败");
  }
  }
}

结果如下：

Thread-0获得了锁

Thread-1获取锁失败

Thread-0释放了锁

如上，tryLock是用判断当前锁的状态，获取到返回true，否则返回false。

中断线程

public class Demo5 {
  Lock lock = new ReentrantLock();
  public static void main(String[] args) {
  Demo5 demo = new Demo5();
  Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
    try {
      demo.Test();
    } catch (InterruptedException e) {
      System.out.println(Thread.currentThread().getName()+"线程被中断");
      e.printStackTrace();
    }
    }
  });
  Thread t2 = new Thread(new Runnable() {
    @Override
    public void run() {
    try{
    demo.Test();
    }catch(Exception e){
      System.out.println(Thread.currentThread().getName()+"线程被中断");
    }
    }
  });
  t1.start();
  t2.start();
  t2.interrupt();
  }
  public void Test() throws InterruptedException{
    lock.lockInterruptibly();//获取锁
    try{
    System.out.println(Thread.currentThread().getName()+"获得了锁");
    Thread.sleep(2000);
    }catch(Exception e){
    e.printStackTrace();
    }finally {  
    System.out.println(Thread.currentThread().getName()+"释放了锁");
    lock.unlock();
    }
  }
}

结果如下：

Thread-0获得了锁

Thread-1线程被中断

Thread-0释放了锁

只有调用lockInterruptibly方法获取的锁才可以中断。

Lock和Synchronized的区别:

Lock是java语言写的，是一个接口。而Synchronized是java内置的。

lock获取的锁是可以中断的，而Synchronized则是一直阻塞，直到获取锁。

Synchronized执行完后会自动释放锁，而lock必须手动的释放锁，不然容易造成死锁。

通过lock可以知道当前线程有没有获取到锁。

重入锁

public  synchronized void method1(){  
    System.out.println("method1------开始");
    try {
    Thread.sleep(2000);
    method2();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println("method1------结束");
  }
  public synchronized void method2(){ 
    System.out.println("method2------开始");
    try {
    Thread.sleep(2000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println("method2------结束");
   }

如上所示：

当一个线程执行到method1的时候，获得锁，进入方法然后又会调用method2。这个时候就不需要在获取锁了，因为Synchronized是可重入锁。所以不需要再次获取锁。当然lock也是可重入锁。

可中断锁：

在java 中，lock锁可以被中断，但是Synchronized不可以被中断。当一个线程被阻塞的时候，可以中断他的阻塞，然后让他去执行别的任务，这样就是可中断锁。

在上面已经做过演示了。

读写锁：ReadWriteLock 他也是一个接口

分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。总之，读的时候上读锁，写的时候上写锁！

比如说在写文件的时候，分成2个锁来分配给线程，从而可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写文件的效率。该接口也有一个实现类ReentrantReadWriteLock，下面我们就来学习下这个类。

读操作：

public class Demo5 {
  ReadWriteLock lock = new ReentrantReadWriteLock();
  public static void main(String[] args) {
  Demo5 demo = new Demo5();
  Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();
    }
  });
  Thread t2 = new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();  
    }
  });
  t1.start();
  t2.start();
  }
  public void Test() {
    lock.readLock().lock();;//获取锁
    try{
    for (int i = 0; i <5; i++) {
      Thread.sleep(100);
      System.out.println(Thread.currentThread().getName()+"读操作");
    }
    }catch(Exception e){
    e.printStackTrace();
    }finally {  
    lock.readLock().unlock();
    System.out.println(Thread.currentThread().getName()+"释放了锁");
    }
  }
}

结果如下所示：

Thread-0读操作

Thread-1读操作

Thread-0读操作

Thread-1读操作

Thread-0读操作

Thread-1读操作

Thread-0读操作

Thread-1读操作

Thread-0释放了锁

Thread-1释放了锁

可以看到使用了读锁之后，多个线程可以同时访问Test方法。

写操作

public class Demo5 {
  ReadWriteLock lock = new ReentrantReadWriteLock();
  public static void main(String[] args) {
  Demo5 demo = new Demo5();
  Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();
    }
  });
  Thread t2 = new Thread(new Runnable() {
    @Override
    public void run() {
    demo.Test();  
    }
  });
  t1.start();
  t2.start();
  }
  public void Test() {
    lock.writeLock().lock();;//获取锁
    try{
    for (int i = 0; i <5; i++) {
      Thread.sleep(100);
      System.out.println(Thread.currentThread().getName()+"写操作");
    }
    }catch(Exception e){
    e.printStackTrace();
    }finally {  
    lock.writeLock().unlock();
    System.out.println(Thread.currentThread().getName()+"释放了锁");
    }
  }
}

结果如下：

Thread-0写操作

Thread-0释放了锁

Thread-1写操作

Thread-1释放了锁

由结果可得当使用写锁的时候，只能有一个线程执行Test方法。

读写锁将一个资源分成了两个锁，分别是读锁，和些锁。

可以通过readLock()获取读锁，writeLock()获的写锁。

使用读锁可以被大量的线程访问，但是要保证是同一对象。使用写锁在同一时间内只能被一个线程访问。

线程同步的方法：Synchronized、Lock、ReentrantLock分析

Synchronized修饰的代码块或者方法被某个线程获取到之后，其他线程就会被阻塞。当被修饰的方法执行完后则自动释放锁

Lock是一个接口，lock提供比Synchronized更广泛的锁操作，他们允许更灵活的结构化可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

是可重入锁，ReentrantLock是唯一实现了Lock接口的类，并且提供了更多的使用方法。

热门文章

最新文章

相关电子书

线程同步的方法：Synchronized、Lock、ReentrantLock分析

Synchronized修饰的代码块或者方法被某个线程获取到之后，其他线程就会被阻塞。当被修饰的方法执行完后则自动释放锁

Lock是一个接口，lock提供比Synchronized更广泛的锁操作，他们允许更灵活的结构化可能具有完全不同的属性 ，并且可以支持多个相关联的对象Condition 。

是可重入锁，ReentrantLock是唯一实现了Lock接口的类，并且提供了更多的使用方法。

热门文章

最新文章

相关电子书

Lock是一个接口，lock提供比Synchronized更广泛的锁操作，他们允许更灵活的结构化可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。