Lock接口与读写锁（lock 和 synchronized 的比较）

来源：互联网发布：一句话经典知乎编辑：程序博客网时间：2024/06/07 12:52

出现：JDK1.5

实现类：

ReentrantLock（重入锁、手工锁）

ReentrantReadWriteLock.ReadLock ReentrantReadWriteLock.WriteLock

主要方法：

lock() unlock()

使用：

TestLock.java

public class TestLock implement Runnable{
    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run(){
        
            try{
                //加锁
                lock.lock();
                //执行同步代码
            }
            finally{
                //释放锁
                lock.unlock();
            }
}

和synchronized互斥锁的比较：

（1）synchronized关键字修饰的代码是完全互斥的，而Lock更加灵活，可以实现多线程同时读共享数据（读锁和读锁不互斥），但读锁和写锁互斥。写锁和写锁互斥（读写锁）。

（2）ReentrainLock有tryLock方法：

public class ReentrainLockTest{
    //获取锁
    Lock lock = new ReentrainLock();
    //线程1的方法：获取锁
    void m1(){
        lock.lock();//锁定
        try{
            for(int i=0;i<10;i++){//锁定10秒
                TimeUtil.SECONDS.sleep(1);//sleep 1秒
            }
        }catch(InterruptException e){
            e.printStackTrace();
        }finally{
            lock.unlock();//10秒后释放锁
        }
    }
    //线程2的方法
    void m2(){
        boolean locked = lock.tryLcok();//尝试锁定，如果返回为false，则获取锁失败，但程序继续执行。
        Systerm.out.println("是否获得锁：" + locked);
        if(locked) lock.unlock();//如果获得锁，则解锁
    }
    
    public static void main(String[] args){
        //开启两个线程，线程1调用m1方法，线程2调用m2方法
    } 
}

（3）lockInterruptibly方法持有的锁，如果没获取到锁可被其它线程打断

public class{
    public static void main(Stirng[] args){
        Lock lock = new ReentrainLock();
        //1.创建t1线程，一直持有锁
        Thread t1 = new Thread(()-> {
            lock.lock();
            try{
                while(true){//一直持有锁
                    TimeUtils.SECOND.sleep(1);
                }
            }catch(InterruptException e){
                e.printStackTrace();
            }fainally{
                lock.unlock();//释放锁
            }
        });
        t1.start();
        
        //2.启动t2线程，尝试获取锁，但是一直获取失败（t1线程一直持有锁）
        Tread t2 = new Thread(()->{
            try{
                boolean isLocked = lock.tryLock();
                lock.lockInterruptibly();//表示可以对其它线程的interrupt方法做出响应
                System.out.println("t2线程启动！");
            }catch(InterruptException e){
                e.printStackTrace();
            }finally{
                if(isLocked) lock.unlock();
            }
            
        });
        t2.start();
        
        //3.主线程1秒后打断t2线程的等待锁状态，t2线程结束，抛出异常
        try{
            timeUtils.SECONDS.sleep(1)
        }catch(InterruptException e){
            e.printStackTrace();
        }
        t2.interrupt();
    }
}

（4）reentrianLock可以指定公平锁（synchronized为不公平锁）

synchronized在锁释放时，所有线程都在竞争锁（不确定谁能拿到锁），很可能有的线程一次都拿不到，不公平

reentrianLock可以在锁竞争时，判断哪个线程等待的时间长，就先让哪个线程获取锁

Lock lock = new ReentrainLock(true);//传入true为公平锁，默认为非公平锁

读写锁接口：

ReadWriteLock

实现类：

ReentranReadWriteLock

方法：

readLock、writeLock（返回Lock对象）

使用：

ReadWriteLock rwl = new ReenTranReadWriteLock();
rwl.readLock().lock();//获取读锁
rwl.readLock().unLock();//释放读锁
rwl.writeLock().lock();//获取写锁
rwl.writeLock().unLock();//释放写锁

例子：用户从银行读取余额（读锁，多用户同时读一个账号）。用户从银行存取钱（写锁，每次只能一个用户从同一个账号存取钱）

用户账户类：MyAccount.java

public class MyCount {  
         private String oid;         //账号  
         private int cash;             //账户余额  
  
         MyCount(String oid, int cash) {  
                 this.oid = oid;  
                 this.cash = cash;  
         }  
  
         public String getOid() {  
                 return oid;  
         }  
  
         public void setOid(String oid) {  
                 this.oid = oid;  
         }  
  
         public int getCash() {  
                 return cash;  
         }  
  
         public void setCash(int cash) {  
                 this.cash = cash;  
         }  
  
         @Override  
         public String toString() {  
                 return "MyCount{" +  
                                 "oid='" + oid + '\'' +  
                                 ", cash=" + cash +  
                                 '}';  
         }  
}  

线程类（多用户同时访问一个账号）：UserThread.java

public class UserThread implements Runnable {  
         private String name;                 //用户名  
         private MyCount myCount;         //所要操作的账户  
         private int iocash;                 //操作的金额，当然有正负之分了  
         private ReadWriteLock myLock;                 //执行操作所需的锁对象  
         private boolean ischeck;         //是否查询  
  
         public UserThread(String name, MyCount myCount, int iocash, ReadWriteLock myLock, boolean ischeck) {  
                 this.name = name;  
                 this.myCount = myCount;  
                 this.iocash = iocash;  
                 this.myLock = myLock;  
                 this.ischeck = ischeck;//是否查看余额  
         }  
  
         public void run() {  
                 if (ischeck) {  //查看余额
                         //获取读锁  
                         myLock.readLock().lock();  
                         System.out.println("读：" + name + "正在查询" + myCount + "账户，当前金额为" + myCount.getCash());  
                         //释放读锁  
                         myLock.readLock().unlock();  
                 } else {  //存取钱
                         //获取写锁  
                         myLock.writeLock().lock();  
                         //执行现金业务  
                         System.out.println("写：" + name + "正在操作" + myCount + "账户，金额为" + iocash +"，当前金额为" + myCount.getCash());  
                         myCount.setCash(myCount.getCash() + iocash);  
                         System.out.println("写：" + name + "操作" + myCount + "账户成功，金额为" + iocash +"，当前金额为" + myCount.getCash());  
                         //释放写锁  
                         myLock.writeLock().unlock();  
                 }  
         }  
}  

测试类：Test.java

public class Test {  
         public static void main(String[] args) {  
                 //创建并发访问的账户  
                 MyCount myCount = new MyCount("95599200901215522", 10000);  
                 //创建一个锁对象  
                 ReadWriteLock lock = new ReentrantReadWriteLock(false);  
                 //创建一个线程池  
                 ExecutorService pool = Executors.newFixedThreadPool(2);  
                 //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊  
                 User u1 = new User("Mike", myCount, -4000, lock, false);  
                 User u2 = new User("Mike's Dad", myCount, 6000, lock, false);  
                 User u3 = new User("Mike's Brother", myCount, -8000, lock, false);  
                 User u4 = new User("Mike's Mom", myCount, 800, lock, false);  
                 User u5 = new User("Mike's son", myCount, 0, lock, true);  
                 //在线程池中执行各个用户的操作  
                 pool.execute(u1);  
                 pool.execute(u2);  
                 pool.execute(u3);  
                 pool.execute(u4);  
                 pool.execute(u5);  
                 //关闭线程池  
                 pool.shutdown();  
         }  
}  

锁升级和降级原则：

读锁不可升级成写锁（读锁释放前不可以加写锁）

写锁可以降级成读锁（写锁释放前可以加读锁）

官方文档读写锁例子：

 class CachedData {
   Object data;
   volatile boolean cacheValid;
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
   void processCachedData() {
     rwl.readLock().lock();
     if (!cacheValid) {//第一重检测，没有缓存数据，释放读锁，加写锁写数据
        // 在写锁前必须释放读锁
        rwl.readLock().unlock();
        rwl.writeLock().lock();
        try {
          //第二重检测，写数据前再次确保缓存没有数据，防止在第10行释放了读锁后，被其它线程的写锁拿到，往缓存里写了数据
          if (!cacheValid) {
            data = ...//数据库写入修改操作
            cacheValid = true;
          }
          // 锁降级，在写锁里面先上读锁，把写锁降级成读锁
          rwl.readLock().lock();
        } finally {
          rwl.writeLock().unlock(); // 在读锁状态下释放写锁
        }
     }
     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }

阅读全文

0 0