线程特征-锁

最新推荐文章于 2022-05-02 20:55:20 发布

angel泪

最新推荐文章于 2022-05-02 20:55:20 发布

阅读量282

点赞数

分类专栏：多线程文章标签：线程 jdk

本文链接：https://blog.csdn.net/u013164612/article/details/51933314

版权

多线程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

锁？

一提到线程里面锁，可能很多人想到synchronized这个关键字，可能想到生产者和消费者的故事，哲学家进餐的故事等等一系列的事情，但是其实线程中还有一个锁就是lock这个接口，其中jdk是这么解释的：Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。
synchronized 方法或语句的使用提供了对与每个对象相关的隐式监视器锁的访问，但却强制所有锁获取和释放均要出现在一个块结构中：当获取了多个锁时，它们必须以相反的顺序释放，且必须在与所有锁被获取时相同的词法范围内释放所有锁。
虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。例如，某些遍历并发访问的数据结果的算法要求使用 “hand-over-hand” 或 “chain locking”：获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放 B 并获取 D，依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁，从而支持使用这种技术。
随着灵活性的增加，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下，应该使用以下语句：

Lock l = ...; 
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

这些内容主要集中在 java.util.concurrent.locks 下面的Condition、lock、ReadWriteLock三个接口上。上面已经根据jdk文档介绍了lock这个接口的基本内容，那么下面就来说说另外两个接口吧

Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
作为一个示例，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存 put 线程和 take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个 Condition 实例来做到这一点。

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length) 
         notFull.await();
       items[putptr] = x; 
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }
   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0) 
         notEmpty.await();
       Object x = items[takeptr]; 
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   } 
 }

ReadWriteLock接口：
ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。所有 ReadWriteLock 实现都必须保证writeLock 操作的内存同步效果也要保持与相关 readLock 的联系。也就是说，成功获取读锁的线程会看到写入锁之前版本所做的所有更新。
下面写个存钱取钱的例子看看吧（lock接口的例子）：

package com.lilei;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static void main(String[] args) {
        //创建并发访问的账户
        MyCount myCount = new MyCount("95599200901215522", 10000);
        //创建一个锁对象
        Lock lock = new ReentrantLock();
        ExecutorService pool = Executors.newCachedThreadPool();//创建一个尺寸可变的线程池
        //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
        User u1 = new User("张三", myCount, -4000, lock);
        User u2 = new User("张三他爹", myCount, 6000, lock);
        User u3 = new User("张三他弟", myCount, -8000, lock);
        User u4 = new User("张三", myCount, 800, lock);
        //在线程池中执行各个用户的操作
        pool.execute(u1);
        pool.execute(u2);
        pool.execute(u3);
        pool.execute(u4);
        //关闭线程池
        pool.shutdown();
    }
}
class User implements Runnable{
    private String name;
    private MyCount count;
    private int iocash;
    private Lock lock;
    public User(String name, MyCount count, int iocash, Lock lock) {
        super();
        this.name = name;
        this.count = count;
        this.iocash = iocash;
        this.lock = lock;
    }
    @Override
    public void run() {
        lock.lock();//获取锁
        //执行现金业务
        System.out.println(name + "正在操作" + count + "账户， 金额为" +
        iocash + "，当前金额为" + count.getCash());
        count.setCash(count.getCash() + iocash);
        System.out.println(name + "操作" + count + "账户成功， 金额为" +
        iocash + "，当前金额为" + count.getCash());
        //释放锁，否则别的线程没有机会执行了
        lock.unlock();
    }
}
class MyCount{
    private String oid;//账号
    private int cash;//账户余额
    public 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 + "]";
    }

}

利用锁对象是不是方便了好多，是不是比直接在某个不知情的对象上清晰好多，但是一定要注意，获取了锁对象，用完了以后记得把锁释放掉，不然别人就用不了了。
下面的例子是ReadWriteLock（读写锁）：

package com.lilei;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class TestReadWriteLock {
    public static void main(String[] args) {
        //创建并发访问的账户
        MyCount1 myCount = new MyCount1("95599200901215522", 10000);
        //创建一个锁对象
        ReadWriteLock lock = new ReentrantReadWriteLock(false);
        //创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
        User1 u1 = new User1("张三", myCount, -4000, lock, false);
        User1 u2 = new User1("张三他爹", myCount, 6000, lock, false);
        User1 u3 = new User1("张三他弟", myCount, -8000, lock, false);
        User1 u4 = new User1("张三", myCount, 800, lock, false);
        User1 u5 = new User1("张三他爹", myCount, 0, lock, true);
        pool.execute(u1);
        pool.execute(u2);
        pool.execute(u3);
        pool.execute(u4);
        pool.execute(u5);
        //关闭线程池
        pool.shutdown();
    }
}
class User1 implements Runnable{
    private String name; //用户名
    private MyCount1 myCount; //所要操作的账户
    private int iocash; //操作的金额，当然有正负之分了
    private ReadWriteLock myLock; //执行操作所需的锁对象
    private boolean ischeck; //是否查询
    public User1(String name, MyCount1 myCount, int iocash,
            ReadWriteLock myLock, boolean ischeck) {
        super();
        this.name = name;
        this.myCount = myCount;
        this.iocash = iocash;
        this.myLock = myLock;
        this.ischeck = ischeck;
    }
    @Override
    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();
        }
    }
}
class MyCount1{
    private String oid;//账号
    private int cash;//账户余额
    public MyCount1(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 + "]";
    }
}