疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

synchronized和lock比对


 

  

  1:获取Lock锁的几种方式

  前面说了synchronized有锁对象和锁类对象,当某个线程获取锁其他线程必须等待执行完毕才可继续进行,比如线程A先获取锁,但是出现异常导致的后果就是线程B无法获取锁,会出现死锁的情况,那么我们一起看看Lock是如何解决的。lock有4种方式来获取锁

  1:lock.lock() 如果获取了锁立即返回,如果别的线程持有锁,当前线程则一直处于休眠状态,直到获取锁。此种模式和synchronized一样但是不会出现死锁

  public class Lock1 {

  static int value = 0;

  static Lock lock = new ReentrantLock();

  static class Task1 implements Runnable {

  public void run() {

  System.out.println("线程" + Thread.currentThread().getName() + "开始执行");

  lock.lock();

  try {

  for (int i = 0; i < 1000000; i++) {

  value++;

  }

  System.out.println(value);

  } finally {

  lock.unlock();

  }

  }

  }

  static class Task2 implements Runnable {

  public void run() {

  System.out.println("线程" + Thread.currentThread().getName() + "开始执行");

  lock.lock();

  try {

  for (int i = 0; i < 1000000; i++) {

  value++;

  }

  System.out.println(value);

  } finally {

  lock.unlock();

  }

  }

  }

  public static void main(String[] args) {

  ExecutorService service= Executors.newCachedThreadPool();

  service.execute(new Task1());

  service.execute(new Task2());

  service.shutdown();

  }

  }

  复制代码

  输出结果很明显其中一个value是1000000,一个是2000000,效果和synchronized是一样的。但是如果我们去掉lock以后的结果呢,很明显会错,如下图这样

  为啥会出现这样情况呢,是由于cpu速度极快,每次处理完毕之后并没有立即把数值放入Java内存中,而是放在写缓存区,然后由写缓存区同步到Java内存中,这样一样,如果线程1计算结果是2,但是还是到内存中,导致线程2以为value值还是1所以会重复计算,还有从结果我们也可以看出value值并不是100000说明2个线程是同步执行的。

  2:lock.tryLock();

  这个方法和synchronized有所不同,synchronized和lock都会等待直到获取锁。如果获取了锁立即返回true,如果别的线程正持有锁,立即返回false;当然我们可以利用while循环一直等待,直到获取锁然后进行。代码如下

  复制代码

  public class Lock2 {

  public static void main(String[] args) {

  final Lock lock = new ReentrantLock();

  Thread t1 = new Thread(new Runnable() {

  public void run() {

  String tName = Thread.currentThread().getName();

  while (!lock.tryLock()) {

  try {

  TimeUnit.SECONDS.sleep(1);

  } catch (InterruptedException e) {

  e.printStackTrace();

  }

  System.out.println("等待获取锁");

  }

  try {

  for (int i = 0; i < 5; i++) {

  System.out.println(tName + ":" + i);

  }

  Thread.sleep(5000);

  } catch (InterruptedException e) {

  e.printStackTrace();

  } finally {

  lock.unlock();

  }

  }

  });

  Thread t2 = new Thread(new Runnable() {

  public void run() {

  String tName = Thread.currentThread().getName();

  while (!lock.tryLock()) {

  try {

  TimeUnit.SECONDS.sleep(1);

  } catch (InterruptedException e) {

  e.printStackTrace();

  }

  System.out.println("等待获取锁");

  }

  try {

  for (int i = 0; i < 5; i++) {

  System.out.println(tName + ":" + i);

  }

  } catch (Exception e) {

  System.out.println(tName + "出错了!!!");

  } finally {

  System.out.println(tName + "释放锁!!");

  lock.unlock();

  }

  }

  });

  t1.start();

  t2.start();

  }

  }

  复制代码

  3:lock.trylock(long time, TimeUnit unit)如果获取了锁定立即返回true,如果别的线程正持有锁,会等待参数给定的时间,在等待的过程中,如果获取了锁定,就返回true,如果等待超时,返回false;unit是time的时间单位比如TimeUnit.SECONDS就是表示秒

  4:lock.lockInterruptibly()如果获取了锁定立即返回,如果没有获取锁定,当前线程处于休眠状态,直到或者锁定,或者当前线程被别的线程中断。也就是说如何线程没有被中断和lock.lock()的作用一样。但是如何线程被中断了,那么此时这个线程不会有任何的响应,想象这么一个场景,线程A和线程B同时执行任务,但是必须等待线程B先执行,但是执行过程中突然线程A突然被中断,那么这个时候就可能出现死锁,哪怕是在finally中加入unlock,这个时候我们就要采用lockInterruptibly()了。代码如下

  复制代码

  public class Lock3 {

  public static void main(String[] args) {

  final Lock lock = new ReentrantLock();

  final Thread thread1 = new Thread(new Runnable() {

  public void run() {

  try {

  TimeUnit.SECONDS.sleep(2);

  System.out.println("等待被中断");

  lock.lockInterruptibly();

  } catch (InterruptedException e) {

  System.out.println("我被中断了");

  } finally {

  lock.unlock();

  }

  }

  });

  Thread thread2 = new Thread(new Runnable() {

  public void run() {

  lock.lock();

  try {

  TimeUnit.SECONDS.sleep(4);

  } catch (InterruptedException e) {

  }

  thread1.interrupt();

  System.out.println("线程1已经被中断");

  }

  });

  thread1.start();

  thread2.start();

  }

  }

  复制代码

  2:读锁和写锁

  在开发中我们最好的愿望就是写的时候加锁,但是读的时候不加锁这样会大大的提升效率,但是采用synchronized却无法满足我们的要求,如果在读的方法面前加锁那么所有的读都需要等待,如果不加锁的话那么如果现在A,B2个线程读取,C线程写入可能导致的后果就是A,B2个线程取得数据不一致,明明同一种业务场景但是获取值却不同。好了lock的读锁和写锁帮助我们实现这种功能。

  复制代码

  public class ReadWriteLockTest {

  private int value = 0;

  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

  public void add(int value) {

  Lock writeLock = readWriteLock.writeLock();

  writeLock.lock();

  try {

  TimeUnit.SECONDS.sleep(3);

  System.out.println("添加开始时间:" + new Date());

  this.value += value;

  } catch (InterruptedException e) {

  e.printStackTrace();

  } finally {

  writeLock.unlock();

  }

  }

  public void getValue() {

  Lock readLock = readWriteLock.readLock();

  readLock.lock();

  try {

  TimeUnit.SECONDS.sleep(1);

  System.out.println("获取开始时间:" + new Date());

  System.out.println(value);

  } catch (InterruptedException e) {

  } finally {

  readLock.unlock();

  }

  }

  public static void main(String[] args) {

  final ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();

  Runnable task1 = new Runnable() {

  public void run() {

  readWriteLockTest.add(100);

  }

  };

  Runnable task2 = new Runnable() {

  public void run() {

  readWriteLockTest.getValue();

  }

  };

  ExecutorService service = Executors.newCachedThreadPool();

  for (int i=0;i<2;i++){

  service.execute(task1);

  }

  for (int i=0;i<2;i++){

  service.execute(task2);

  }

  for (int i=0;i<2;i++){

  service.execute(task1);

  }

  service.shutdown();

  }

  }

  复制代码

  运行结果:

  从这个结果我们很明显的可以总结读锁和写锁

  第一:如果执行写的时候,读和写必须等待

  第二:如果执行读的时候,写必须等待,而读却不用等待

  也就是说读和写必须存在先后顺序,不管是先读还是先写。

  3:总结

  相同点:lock能实现synchronized所有可以实现的

  不同点:

  1:lock不容易出现死锁,而synchronized如果某个线程出现异常就会产生死锁

  2:lock更加灵活,可以通过tryLock来验证是否获取锁,在线程中断也同样可以处理

  3:lock有读写锁在并发量大的时候具有很大的优势,因为读的情况一般会比写多很多