文章目录

  • 公平锁与非公平锁
  • 非公平锁
  • 公平锁
  • 关于公平锁与非公平锁的区别
  • 可重入锁（也叫作递归锁）
  • 举例
  • 自旋锁
  • 自旋锁的好处
  • 举例
  • 独占锁（写锁）/共享锁（读锁）/互斥锁
  • 举例（未使用读写锁）
  • 举例（使用读写锁）


公平锁与非公平锁

    用过并发包的朋友对这个应该不会陌生，ReentrantLock 是 Java 的 JUC（java.util.concurrent）包中提供的一种可重入锁，是一种递归无阻塞的同步机制。ReentrantLock 等同于synchronized关键字，但是 ReentrantLock 提供了比 synchronized 更强大，更灵活的锁机制，可以减少死锁发生的概率

java如何锁住同一个用户_公平锁

非公平锁

    ReentrantLock 还提供了公平锁（fair）和非公平锁（unfair）。非公平锁是当锁被释放的时候，等待中的线程均有机会获得锁。有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级反转或者饥饿现象synchronized是非公平锁，而 ReentrantLock 也是一样。但是 ReentrantLock 可以通过构造方法接收一个可选的fair参数（默认是非公平锁）

java如何锁住同一个用户_java如何锁住同一个用户_02

公平锁

所谓的公平锁就是指锁的获取策略相对公平，当多个线程在获取同一个锁的时候，必须按照锁的申请时间来一次获得锁，也就是按顺序来

java如何锁住同一个用户_java_03


当传入的值为 true 时则表示是公平锁，源码如下：

java如何锁住同一个用户_System_04

关于公平锁与非公平锁的区别

  • 公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当线程是等待队列的第一个，就占有锁。否则就会加入到等待队列中，以后会按照 FIFO（先进先出原则）从队列中获取到自己
  • 非公平锁：非公平比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的那种方式

对于 ReentrantLock 而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大

对于 synchronized 而言，也是一种非公平锁

可重入锁（也叫作递归锁）

指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁

简单地说，线程可以进入任何一个它已经拥有的锁所同步着的代码块

举例

package concurrency.day0411;

/**
 * @author Woo_home
 * @create by 2020/4/11  20:06
 */

// 线程操纵资源类
class ThreadDemo {
	// 定义一个同步方法
    public synchronized void seyHello() {
        System.out.println(Thread.currentThread().getName() + " say Hello");
        // 在同步方法内调用另一个同步方法
        seyHi();
    }
    // 定义一个同步方法（被另一个同步方法调用的同步方法）
    public synchronized void seyHi() {
        System.out.println(Thread.currentThread().getName() + " say Hi");
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        ThreadDemo demo = new ThreadDemo();
        new Thread(() -> {
            demo.seyHello();
        },"T1").start();

        new Thread(() -> {
            demo.seyHello();
        },"T2").start();
    }
}

输出：

java如何锁住同一个用户_公平锁_05

自旋锁

是指尝试获取锁的线程不会立即阻塞，而是 采用循环的方式去尝试获取锁，这样的好处是减少线程上下文的切换的消耗，缺点是循环会消耗 CPU

java如何锁住同一个用户_java_06

自旋锁的好处

循环比较获取直到成功为止，没有类似 wait 的阻塞

举例

package concurrency.day0411;

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

/**
 * @author Woo_home
 * @create by 2020/4/11  20:42
 */
public class CASDemo {

    // 原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in");
        while (!atomicReference.compareAndSet(null,thread)) {

        }
    }

    public 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) {
        CASDemo casDemo = new CASDemo();

        new Thread(() -> {
            casDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            casDemo.myUnLock();
        },"A").start();

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

        new Thread(() -> {
            casDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            casDemo.myUnLock();
        },"B").start();
    }
}

输出：

java如何锁住同一个用户_System_07

独占锁（写锁）/共享锁（读锁）/互斥锁

  • 独占锁（写锁）：指的是该锁一次只能被一个线程所持有。对 ReentrantLock 和 synchronized 而言都是独占锁
  • 共享锁（读锁）：指的是该锁可被多个线程锁持有。对 ReentrantReadWriteLock 其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的

多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。但是如果有一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写

小总结：

  • 读 - 读能共存
  • 写 - 写不能共存

写操作：原子 + 独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断

举例（未使用读写锁）

package concurrency.day0411;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author Woo_home
 * @create by 2020/4/12  12:39
 */

class MyCache { // 资源类
    private volatile Map<String,Object> map = new HashMap<>();

	// 写入操作
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
    }

	// 读取操作
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "\t 正在读取：");
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + result);
    }
}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

		// 5个线程写入数据
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

		// 5个线程读取数据
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
}

输出：

java如何锁住同一个用户_java_08


可以发现打印乱七八糟的，一个线程还没写入完成另一个线程就跟着写入了

举例（使用读写锁）

package concurrency.day0411;

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

/**
 * @author Woo_home
 * @create by 2020/4/12  12:39
 */

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.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
        } 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.MILLISECONDS.sleep(300);
            } 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();
        }
    }
}

public class ReadWriteLockDemo {
    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();
        }
    }
}

java如何锁住同一个用户_java如何锁住同一个用户_09