java锁、公平锁、非公平锁、递归锁、自旋锁、读写锁

一、公平锁和非公平锁

直接上图看吧

二、递归锁

代码案例

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

/**
 * @author yangjikang
 * @date 2019/6/14 15:48
 * @description 递归锁的测试案例
 * @modified By yangjikang
 */
public class TestLock {

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendMs();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"T1").start();

        new Thread(()->{
            try {
                phone.sendMs();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}
//手机
class Phone{
    public synchronized void sendMs() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t invoked sendMs()");
        sendEmail();
    }
    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName()+"\t invoked sendEmail()");
    }
}

控制台效果图

三、自旋锁

3.1代码案例

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @author yangjikang
 * @date 2019/6/14 15:48
 * @description 自旋锁的测试案例
 * @modified By yangjikang
 */
public class TestLock {

     static AtomicReference<Thread> atomicReference = new AtomicReference<>();
    public static void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t coming");
        while (!atomicReference.compareAndSet(null,thread)){

        }
    }
    public static void myUnLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t invoked myUnLock");
    }
    public static void main(String[] args) {
        new Thread(()->{
            TestLock.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            TestLock.myUnLock();
        },"T1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            TestLock.myLock();
            TestLock.myUnLock();
        },"T2").start();
    }
}

控制台效果图

四、读写锁

4.1正常加锁的情况

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author yangjikang
 * @date 2019/6/14 15:48
 * @description 读写锁的测试案例
 * @modified By yangjikang
 */
public class TestLock {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() ->{
                    myCache.put(tempInt + "", tempInt);
            }, String.valueOf(i)).start();
        }
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() ->
                    myCache.get(tempInt + ""), String.valueOf(i)).start();
        }
    }
}

class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();
    private Lock lock = new ReentrantLock();

    public void put(String key, Object value) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 开始写入...");
            //模拟网络拥堵
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void get(String key) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 开始读取...");
            //模拟网络拥堵
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

控制台效果图

4.2加读写锁的效果

代码案例

/*
 * Copyright (C), 2013-2019, 天津大海云科技有限公司
 */

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author yangjikang
 * @date 2019/6/14 15:48
 * @description 读写锁的测试案例
 * @modified By yangjikang
 */
public class TestLock {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() ->{
                    myCache.put(tempInt + "", tempInt);
            }, String.valueOf(i)).start();
        }
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() ->
                    myCache.get(tempInt + ""), String.valueOf(i)).start();
        }
    }
}

class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 开始写入..."+key);
            //模拟网络拥堵
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 开始读取...");
            //模拟网络拥堵
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成..."+result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

控制台效果图