多线程锁

常见锁介绍

synchronized锁的八中情况

package com.shaonian.juc.more_thread_lock;

import java.util.concurrent.TimeUnit;

class Phone {

    public static synchronized void sendSMS() throws Exception {
        //停留4秒
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }

    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }

    public void getHello() {
        System.out.println("------getHello");
    }
}

/**
 * @Description: 8锁
 *
1 标准访问，先打印短信还是邮件
------sendSMS
------sendEmail

2 停4秒在短信方法内，先打印短信还是邮件
------sendSMS
------sendEmail

3 新增普通的hello方法，是先打短信还是hello
------getHello
------sendSMS

4 现在有两部手机，先打印短信还是邮件
------sendEmail
------sendSMS

5 两个静态同步方法，1部手机，先打印短信还是邮件
------sendSMS
------sendEmail

6 两个静态同步方法，2部手机，先打印短信还是邮件
------sendSMS
------sendEmail

7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件
------sendEmail
------sendSMS

8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件
------sendEmail
------sendSMS

 */

public class Lock8QuestionBySynchronized {
    public static void main(String[] args) throws Exception {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                // phone.sendEmail();
                // phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

代码结果原因分析，见博客中synchronized关键字回顾。

ReentrantLock读写锁分析

/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();//默认是非公平锁
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {//传入false，定义的就是非公平的读写锁
        sync = fair ? new FairSync() : new NonfairSync();
    }

非公平锁(ReentrantLock实现)

非公平锁是多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。确定可能会出现线程饿死现象(锁一直被一个线程持有，某些线程一直拿不到锁)，优点是执行效率高，可以直接获取锁。

static final class NonfairSync extends Sync {//ReentrantLock中的静态内部类
	private static final long serialVersionUID = 7316153563782823691L;

/**
 * Performs lock.  Try immediate barge, backing up to normal
 * acquire on failure.
 */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

公平锁(ReentrantLock实现)

公平锁是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。保证每个线程都能拿到锁，优点是执行效率比非公平锁低，优点是不会出现线程饿死现象。

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

    /**
     * Fair version of tryAcquire.  Don't grant access unless
     * recursive call or no waiters or is first.
     */
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

可重入锁(ReentrantLock实现)

synchronized(隐式)和Lock(显式)都是可重入锁，也叫递归锁。特点，类似于，有了第一把锁，此锁内部锁的代码都可以访问。像开了大门，开剩下的门就不用再用钥匙开门了。

/**
 * @author 长名06
 * @version 1.0
 * 可重入锁案例
 */
public class ReentrantLockDemo {

    private synchronized void add(){
        add();
    }


    public static void main(String[] args) {

        //new ReentrantLockDemo().add();//会出现StackOverflowError

        Object o = new Object();

        new Thread(() -> {
            synchronized (o){
                System.out.println(Thread.currentThread().getName() + "外部");
                synchronized (o){
                    System.out.println(Thread.currentThread().getName() + "中部");
                    synchronized (o){
                        System.out.println(Thread.currentThread().getName() + "内部");
                    }
                }
            }
        },"aa").start();
        
        ReentrantLock lock = new ReentrantLock();
        new Thread(() -> {
            try{
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "外层操作");
                try{
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + "内层操作");

                }finally {
                    lock.unlock();
                }
            }finally {
                lock.unlock();
            }
        }).start();
     //结果
     //Thread-0外层操作
     //Thread-0内层操作
    }
}

死锁

基本介绍

死锁，是一种多个线程在执行过程中，因竞争资源时，导致线程互相持有其他线程执行需要的锁，从而引起线程等待的现象。在没有外力的作用下，程序会崩溃。

引起死锁的原因

1.系统资源不足。
2.进程运行顺序不合适。
3.资源分配不当。

/**
 * @author 长名06
 * @version 1.0
 * 死锁代码
 */
public class DeadLock {

    static Object a = new Object();
    static Object b = new Object();
    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (a){
                System.out.println(Thread.currentThread().getName() + "持有锁a，试图后去锁b");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println(Thread.currentThread().getName() + "获取锁b");
                }
            }
        },"a").start();

        new Thread(() -> {
            synchronized (b){
                System.out.println(Thread.currentThread().getName() + "持有锁b，试图后去锁a");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){
                    System.out.println(Thread.currentThread().getName() + "获取锁a");
                }
            }
        },"b").start();
    }
}