JUC系列（三） | Lock 锁机制详解 代码理论相结合

public interface Lock {
    void lock(); //获得锁。
    /**
    除非当前线程被中断，否则获取锁。
  如果可用，则获取锁并立即返回。
  如果锁不可用，则当前线程将出于线程调度目的而被禁用并处于休眠状态，直到发生以下两种情况之一：
    锁被当前线程获取； 
    要么其他一些线程中断当前线程，支持中断获取锁。
  如果当前线程：
    在进入此方法时设置其中断状态； 
    要么获取锁时中断，支持中断获取锁，
    */
    void lockInterruptibly() throws InterruptedException; 
    /**
    仅在调用时空闲时才获取锁。
  如果可用，则获取锁并立即返回值为true 。 如果锁不可用，则此方法将立即返回false值。
  */
    boolean tryLock();
    //比上面多一个等待时间 
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;  
    // 解锁
    void unlock(); 
    //返回绑定到此Lock实例的新Condition实例。
    Condition newCondition();  。
}

Lock lock = new ReentrantLock();
try {
    lock.lock();
    System.out.println("上锁了");
}catch (Exception e){
    e.printStackTrace();
}finally {
    lock.unlock();
    System.out.println("解锁了");
}

class Share {
    private Integer number = 0;
    private ReentrantLock lock = new ReentrantLock();
    private Condition newCondition = lock.newCondition();
    // +1 的方法
    public void incr() {
        try {
            lock.lock(); // 加锁
            while (number != 0) {
                newCondition.await();//沉睡
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            newCondition.signal(); //唤醒另一个沉睡的线程 
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    // -1 的方法
    public void decr() {
        try {
            lock.lock();
            while (number != 1) {
                newCondition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            newCondition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class LockDemo2 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(()->{
            for (int i=0;i<=10;i++){
                share.incr();
            }
        },"AA").start();
        new Thread(()->{
            for (int i=0;i<=10;i++){
                share.decr();
            }
        },"BB").start();
        /**
         * AA::1
         * BB::0
         * AA::1
         * BB::0
         * .....
         */     
    }
}

package com.crush.juc02;
import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("第1次获取锁，这个锁是：" + lock);
                    for (int i = 2;i<=11;i++){
                        try {
                            lock.lock();
                            System.out.println("第" + i + "次获取锁，这个锁是：" + lock);
                            try {
                                Thread.sleep(new Random().nextInt(200));
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        } finally {
                           lock.unlock();// 如果把这里注释掉的话，那么程序就会陷入死锁当中。
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          lock.lock();
                    System.out.println("这里是为了测试死锁而多写一个的线程");
        } finally {
          lock.unlock();
        }
      }
    }).start();
    }
}
/**
 * 第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@6b5fde1f[Locked by thread Thread-0]
 * 第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@6b5fde1f[Locked by thread Thread-0]
 * 第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@6b5fde1f[Locked by thread Thread-0]
 * ...
 */

public interface ReadWriteLock {
    // 获取读锁
    Lock readLock();
  // 获取写锁
    Lock writeLock();
}

public class SynchronizedDemo2 {
    public static void main(String[] args) {
        final SynchronizedDemo2 test = new SynchronizedDemo2();
        new Thread(()->{
            test.get(Thread.currentThread());
        }).start();
        new Thread(()->{
            test.get(Thread.currentThread());
        }).start();
    }
    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        while(System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
    }
}
/**
 * 输出
 * Thread-0正在进行读操作
 * Thread-0读操作完毕
 * Thread-1正在进行读操作
 * Thread-1正在进行读操作
 * Thread-1正在进行读操作
 * ....
 * Thread-1读操作完毕
 */

public class SynchronizedDemo2 {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    public static void main(String[] args) {
        final SynchronizedDemo2 test = new SynchronizedDemo2();
        new Thread(()->{
            test.get2(Thread.currentThread());
        }).start();
        new Thread(()->{
            test.get2(Thread.currentThread());
        }).start();
    }
    public void get2(Thread thread) {
        rwl.readLock().lock();
        try {
            long start = System.currentTimeMillis();
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完毕");
        } finally {
            rwl.readLock().unlock();
        }
    }
}
/**
 * 输出
 * Thread-0正在进行读操作
 * Thread-0读操作完毕
 * Thread-1正在进行读操作
 * Thread-1读操作完毕
 */