多线程常见锁的基本用法

CountDownLatch

**官方解释：**一种同步辅助，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成countDownLatch用给定的计数进行初始化。由于对countDown方法的调用，await方法会阻塞直到当前计数达到0，之后所有等待的线程都会被释放，所有后续的await调用都会立即返回。这是一个一次性现象——计数不能重置。如果需要重置计数的版本，可以考虑使用CyclicBarrier。countDownLatch是一个通用的同步工具，可以用于多种目的。用一个计数初始化的CountDownLatch作为一个简单的开/关闩锁，或gate:所有调用await的线程在gate处等待，直到它被调用countDown的线程打开。可以使用初始化为N的CountDownLatch使一个线程等待，直到Nthreads完成某些操作，或者某些操作已经完成N次。CountDownLatch的一个有用属性是，它不要求调用countDown的线程在继续之前等待计数达到0，它只是阻止任何线程继续等待，直到所有线程都可以通过。
案例一、

package duoxiancheng2;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @author yeqv
 * @program A2
 * @Classname T2
 * @Date 2022/2/8 8:38
 * @Email w16638771062@163.com
 */
public class T2 {
    //CountDownLatch
    CountDownLatch latch = new CountDownLatch(1);

    public static void main(String[] args) {

        T2 t = new T2();
        new Thread(() -> t.a(), "A").start();
        new Thread(() -> t.b(), "B").start();
    }

    void a() {
        System.out.println(Thread.currentThread().getName() + "已启动");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        latch.countDown();
        System.out.println(Thread.currentThread().getName() + "已结束");


    }

    void b() {
        System.out.println(Thread.currentThread().getName() + "已启动");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "已结束");

    }
}

**结果：**线程A，B启动。线程A在执行，线程B在等待

当线程A完成操作开锁之后，线程B开始执行（这里是某组操作完成时，也就是执行了countDown()方法。不是说线程A执行完。可能执行到中间就已经开锁了）

ReentrantLock

ReentrantLock 最大的特点公平锁
即哪个线程等待的时间最长优先执行
ReentrantLock常常对比着synchronized来分析，我们先对比着来看然后再一点一点分析。
（1）synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。

（2）synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重入，但加锁和解锁需要手动进行，且次数需一样，否则其他线程无法获得锁。

（3）synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以相应中断。

public class T3 {
    Lock lock = new ReentrantLock(true);//设置为true公平锁，效率低但公平

    void m() {
        for (int i = 0; i <= 20; i++) {
            lock.lock();
            System.out.println(Thread.currentThread().getName());
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch(Exception e){
                e.printStackTrace();
            }
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        var t = new T3();
        new Thread(t::m,"T1").start();
        new Thread(t::m,"T2").start();
        new Thread(t::m,"T3").start();
        new Thread(t::m,"T4").start();
    }
}

ReadWriteLock

ReadWriteLock也是一个接口，提供了readLock和writeLock两种锁的操作机制，一个资源可以被多个线程同时读，或者被一个线程写，但是不能同时存在读和写线程。
假设在程序中定义一个共享的数据结构用作缓存，它大部分时间提供读服务（例如：查询和搜索），而写操作占有的时间很少，但是写操作完成之后的更新需要对后续的读服务可见。
特性：
读-读不互斥
读-写互斥
写-写互斥
案例、

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

        // 一个线程进行写
        new Thread(new Runnable(){
            public void run(){
                rw.set((int)(Math.random()*100));
            }
        },"Write:").start();


        // 100个线程进行读操作
        for(int i=0; i<100; i++){
            new Thread(new Runnable(){
                public void run(){
                rw.get();
                }
            },"Read:").start();
        }
    }
}
 
class ReadWriteLockDemo{
	private int number = 0;
	private ReadWriteLock lock = new ReentrantReadWriteLock();
	// 读
	public void get(){
		lock.readLock().lock(); // 上锁
        try{
        	System.out.println(Thread.currentThread().getName()+":"+number);
        }finally{
        	lock.readLock().unlock(); // 释放锁
        }
	}
    // 写
    public void set(int number){
        lock.writeLock().lock();
        try{
        	System.out.println(Thread.currentThread().getName());
        	this.number = number;
        }finally{
        	lock.writeLock().unlock();
        }
    }
}