Java多线程编程核心技术---Lock的基本概念和使用

Lock接口：

ReentrantLock的基本功能：

　　ReentrantLock的lock和unlock方法进行加锁，解锁。可以起到和synchronized关键字一样的效果；

　　选择性通知！！！：

　　　　　　　　　　　使用Condition实现等待通知，和wait/notifyAll机制一样，要使用await()方法进入WAITING状态，就必须要先使用lock.lock()获得同步监视器。

　　　　　　　　　　

 package service;

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;

 public class MyService {
     private ReentrantLock lock = new ReentrantLock();
     private Condition condition = lock.newCondition();

     public void waitMethod() {
         try {
             lock.lock();
             System.out.println("A");
             condition.await();
             System.out.println("B");
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
             System.out.println("锁释放了！");
         }
     }
 }

　　类比wait/notify机制：wait-->await  notify-->signal notifyAll-->signalAll

　　选择性通知：使用多个Condition实现

　

package service;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {

    private Lock lock = new ReentrantLock();
        // 使用多个Condition  todo 查看原理
    public Condition conditionA = lock.newCondition();
    public Condition conditionB = lock.newCondition();

    public void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionA.await();
            System.out.println("  end awaitA时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionB.await();
            System.out.println("  end awaitB时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signalAll_A() {
        try {
            lock.lock();
            System.out.println("  signalAll_A时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void signalAll_B() {
        try {
            lock.lock();
            System.out.println("  signalAll_B时间为" + System.currentTimeMillis()
                    + " ThreadName=" + Thread.currentThread().getName());
            conditionB.signalAll();
        } finally {
            lock.unlock();
        }
    }
}
    

　　public ReentrantLock(true) 采用公平策略。反之采用不公平策略。

　　tryLock()：如果没被锁定，获得锁。否则不获得锁。

　　tryLock(long timeout , TimeUnit unit)：给宽定时间的tryLock()

 package service;

 import java.util.concurrent.locks.ReentrantLock;

 public class MyService {

     public ReentrantLock lock = new ReentrantLock();

     public void waitMethod() {
         if (lock.tryLock()) {
             System.out.println(Thread.currentThread().getName() + "获得锁");
         } else {
             System.out.println(Thread.currentThread().getName() + "没有获得锁");
         }
     }
 }

 package service;

 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;

 public class MyService {

     public ReentrantLock lock = new ReentrantLock();

     public void waitMethod() {
         try {
             if (lock.tryLock(3, TimeUnit.SECONDS)) {
                 System.out.println("      " + Thread.currentThread().getName()
                         + "获得锁的时间：" + System.currentTimeMillis());
                 Thread.sleep(10000);
             } else {
                 System.out.println("      " + Thread.currentThread().getName()
                         + "没有获得锁");
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         } finally {
             if (lock.isHeldByCurrentThread()) {
                 lock.unlock();
             }
         }
     }
 }

　　使用Codition实现顺序执行

 package test.run;

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;

 public class Run {

     volatile private static int nextPrintWho = 1;
     private static ReentrantLock lock = new ReentrantLock();
     final private static Condition conditionA = lock.newCondition();
     final private static Condition conditionB = lock.newCondition();
     final private static Condition conditionC = lock.newCondition();

     public static void main(String[] args) {

         Thread threadA = new Thread() {
             public void run() {
                 try {
                     lock.lock();
                     while (nextPrintWho != 1) {
                         conditionA.await();
                     }
                     for (int i = 0; i < 3; i++) {
                         System.out.println("ThreadA " + (i + 1));
                     }
                     nextPrintWho = 2;
                     conditionB.signalAll();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     lock.unlock();
                 }
             }
         };

         Thread threadB = new Thread() {
             public void run() {
                 try {
                     lock.lock();
                     while (nextPrintWho != 2) {
                         conditionB.await();
                     }
                     for (int i = 0; i < 3; i++) {
                         System.out.println("ThreadB " + (i + 1));
                     }
                     nextPrintWho = 3;
                     conditionC.signalAll();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     lock.unlock();
                 }
             }
         };

         Thread threadC = new Thread() {
             public void run() {
                 try {
                     lock.lock();
                     while (nextPrintWho != 3) {
                         conditionC.await();
                     }
                     for (int i = 0; i < 3; i++) {
                         System.out.println("ThreadC " + (i + 1));
                     }
                     nextPrintWho = 1;
                     conditionA.signalAll();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 } finally {
                     lock.unlock();
                 }
             }
         };
         Thread[] aArray = new Thread[5];
         Thread[] bArray = new Thread[5];
         Thread[] cArray = new Thread[5];

         for (int i = 0; i < 5; i++) {
             aArray[i] = new Thread(threadA);
             bArray[i] = new Thread(threadB);
             cArray[i] = new Thread(threadC);

             aArray[i].start();
             bArray[i].start();
             cArray[i].start();
         }

     }
 }

ReentrantReadWriteLock：

　　出现目的：ReentrantLock完全互斥排他，效率低下。

　　改善：ReentrantReadWriteLock 读写锁。只要有写操作就是互斥的，没有写操作，就是共享的。

　　

 package service;

 import java.util.concurrent.locks.ReentrantReadWriteLock;

 /*
 output:时间差为10000

 */

 public class Service {

     private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

     public void read() {
         try {
             try {
                 lock.readLock().lock();
                 System.out.println("获得读锁" + Thread.currentThread().getName()
                         + " " + System.currentTimeMillis());
                 Thread.sleep(10000);
             } finally {
                 lock.readLock().unlock();
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     public void write() {
         try {
             try {
                 lock.writeLock().lock();
                 System.out.println("获得写锁" + Thread.currentThread().getName()
                         + " " + System.currentTimeMillis());
                 Thread.sleep(10000);
             } finally {
                 lock.writeLock().unlock();
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

 }