Java并发编程--3.Lock

Lock接口

它提供3个常用的锁

lock() : 获不到锁就就一直阻塞

trylock() ：获不到锁就立刻放回 或者 定时的，轮询的获取锁 

lockInterruptibly() : 获不到锁时阻塞，但可接受中断信号后退出阻塞状态

ReentrantLock

实现机制

基于冲突的乐观并发策略：

如果共享数据被争用，产生了冲突，那就再进行其他的补偿措施，比如说定时的获取锁，直到成功；不需要把线程挂起，也称为非阻塞的同步

公平性

公平： 多个线程在等待同一个锁时，必须按照申请锁的时间顺序排队等待
非公平： 在锁释放时，任何一个等待锁的线程都有机会获得锁，ReentrantLock构造方法，默然是非公平的

什么时候使用

当你需要可定时的和可中断的锁操作，公平队列，或者非块结构的锁，否则请使用synchronized

可中断的例子

public class MyReentrantLock {
    private ReentrantLock lock = new ReentrantLock();  

    public void write() {
        lock.lock();
        try {
            long startTime = System.currentTimeMillis();
            System.out.println("开始往这个buff写入数据…");
            for (;;)// 模拟要处理很长时间
            {
                if (System.currentTimeMillis() - startTime > Integer.MAX_VALUE) {
                    break;
                }
            }
            System.out.println("终于写完了");
        } finally {
            lock.unlock();
        }
    }  

    public void read() throws InterruptedException {
        lock.lockInterruptibly();// 注意这里，可以响应中断
        try {
            System.out.println("从这个buff读数据");
        } finally {
            lock.unlock();
        }
    }  

    public static void main(String args[]) {
        MyReentrantLock buff = new MyReentrantLock();  

        final Writer2 writer = new Writer2(buff);
        final Reader2 reader = new Reader2(buff);  

        writer.start();
        reader.start();  

        new Thread(new Runnable() {  

            @Override
            public void run() {
                long start = System.currentTimeMillis();
                for (;;) {
                    if (System.currentTimeMillis() - start > 5000) {
                        System.out.println("不等了，尝试中断");
                        reader.interrupt();  //此处中断读操作
                        break;
                    }
                }
            }
        }).start();  

    }
}  

class Reader2 extends Thread {  

    private MyReentrantLock buff;  

    public Reader2(MyReentrantLock buff) {
        this.buff = buff;
    }  

    @Override
    public void run() {  

        try {
            buff.read();//可以收到中断的异常，从而有效退出
        } catch (InterruptedException e) {
            System.out.println("我不读了");
        }  

        System.out.println("读结束");  

    }
}  

class Writer2 extends Thread {  

    private MyReentrantLock buff;  

    public Writer2(MyReentrantLock buff) {
        this.buff = buff;
    }  

    @Override
    public void run() {
        buff.write();
    }
}

控制台输出：

开始往这个buff写入数据…
不等了，尝试中断
我不读了
读结束

ReentrantReadWriteLock读写锁

特点

互斥：它使得读写操作互斥，读读操作不互斥

锁降级：写线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁

少写多读的例子

public class MyReadWriteLock {
    public static void main(String[] args) {
        PricesInfo pricesInfo = new PricesInfo();
        Writer writer=new Writer(pricesInfo);
        Reader read =  new Reader(pricesInfo);

        //写线程
        Thread tw=new Thread(writer);
        tw.start();

        //多个读线程
        for (int i=0; i<5; i++){
            Thread tr=new Thread(read);
            tr.start();
        }
    }
}

//读线程
class Reader implements Runnable{
    private PricesInfo pricesInfo;

    public Reader(PricesInfo pricesInfo){
        this.pricesInfo = pricesInfo;
    }

    @Override
    public void run() {
        pricesInfo.getPrice();
    }
}

//写线程
class Writer implements Runnable{
    private PricesInfo pricesInfo;

    public Writer(PricesInfo pricesInfo){
        this.pricesInfo = pricesInfo;
    }

    @Override
    public void run() {
        pricesInfo.setPrice(Math.random()*10);

    }
}

//数据实体
class PricesInfo {
    private double price;

    private ReadWriteLock  lock = new ReentrantReadWriteLock();

    public PricesInfo(){
    }

    //读锁
    public void getPrice(){
        lock.readLock().lock();
        System.out.println(Thread.currentThread().getName()+ " : in read*****************************");
        System.out.println(Thread.currentThread().getName()+ ": 读取数据= " + price);
        lock.readLock().unlock();
    }

    //写锁
    public void setPrice(double price){
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+ " :in Writer==============================================");
            Thread.sleep(1000);
            this.price = price;
            System.out.println(Thread.currentThread().getName()+ ":写入数据= " + price);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }
    }
}

控制台输出：

Thread-0 :in Writer==============================================
Thread-0:写入数据= 3.5843085966236266
Thread-3 : in read*****************************
Thread-3: 读取数据= 3.5843085966236266
......

Condition条件变量

通过ReentrantLock的newCondition()得到Condition对象，它用await()替换wait()，用signal()替换 notify()，用signalAll()替换notifyAll()， 实现线程间的通信;

如果是公平锁，与Condition关联的任务，以FIFO的形式获取锁，否则的话，是随机获取锁；

消费者和生产者的例子

public class MyCondition{
    public static void main(String args[]){
        Info info = new Info(); 

        //启动生产者
        Producer pro = new Producer(info) ;
        new Thread(pro).start() ;  

        try{
            Thread.sleep(100) ;
        }catch(InterruptedException e){
            e.printStackTrace() ;
        }  

        //启动消费者
        Consumer con = new Consumer(info) ;
        new Thread(con).start() ;
    }
}  

class Info{ // 定义信息类
    private String name = null;
    private String content = null ;
    private boolean flag = true ;   // true生产, false消费  

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition(); //产生一个Condition对象  

    public  void set(String name,String content){
        lock.lock();
        try{
            while(!flag){
                condition.await() ;
            }  

            this.setName(name) ;   

            Thread.sleep(300) ;  

            this.setContent(content) ;
            flag  = false ; // 改变标志位，表示可以取走  

            System.out.println("生产者: " + this.getName() +  " --> " + this.getContent()) ;

            condition.signal();
        }catch(InterruptedException e){
            e.printStackTrace() ;
        }finally{
            lock.unlock();
        }
    }  

    public void get(){
        lock.lock();
        try{
            while(flag){
                condition.await() ;
            }     

            Thread.sleep(300) ;  

            System.out.println("消费者: " + this.getName() +  " --> " + this.getContent()) ;  

            flag  = true ;  // 改变标志位，表示可以生产  

            condition.signal();
        }catch(InterruptedException e){
            e.printStackTrace() ;
        }finally{
            lock.unlock();
        }
    }  

    public void setName(String name){
        this.name = name ;
    }
    public void setContent(String content){
        this.content = content ;
    }
    public String getName(){
        return this.name ;
    }
    public String getContent(){
        return this.content ;
    }
}  

/**生产者线程 */
class Producer implements Runnable{
    private Info info = null ;      // 保存Info引用  

    public Producer(Info info){
        this.info = info ;
    }  

    public void run(){
        boolean flag = true ;   // 定义标记位
        for(int i=0;i<10;i++){
            if(flag){
                this.info.set("姓名--1","内容--1") ;
                flag = false ;
            }else{
                this.info.set("姓名--2","内容--2") ;
                flag = true ;
            }
        }
    }
} 

/**消费者线程 */
class Consumer implements Runnable{
    private Info info = null ;  

    public Consumer(Info info){
        this.info = info ;
    }
    public void run(){
        for(int i=0;i<10;i++){
            this.info.get() ;
        }
    }
} 

AQS 和 CAS

AQS : JUC基础类

state : 获取锁的标志

NOde{} : 获取锁的线程
SHARED : 共享锁
EXCLUSIVE : 互斥锁

CLH同步队列

LockSupport.park() 和 LockSupport.unpark() :阻塞和唤醒

CAS: JUC基础理论

对内存*享数据进行操作的指令集, 自动更新共享数据, 代替了锁

内存值V，旧的预期值A，要修改的新值B。当且仅A和内存值V相同时，将内存值V修改为B，否则什么都不做

ABA问题

因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A