JUC第三课——复习、ReentrantLock、CountDownLatch、CyclicBarrier、Phaser、ReadWriteLock、Semaphore、Exchanger

学而知不足~

于 2021-10-15 00:34:15 发布

阅读量134

点赞数

分类专栏： JUC 文章标签： java

本文链接：https://blog.csdn.net/upset_poor/article/details/120734724

版权

JUC 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

CAS复习

是一种乐观锁，使用CPU的原语实现
cas(期望值,更新值)
例子：
m = 0;
m++;

expected = read m;
cas(0,1){
for(;;)如果当前值==0 则m=1
}

AtomicXX类

package character02;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 解决同样问题的更高效的方法，使用AtomXX类
 * AtomXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性
 * @author laimouren
 */
public class CAS01 {
    AtomicInteger count = new AtomicInteger(0);
    void m(){
        for (int i = 0; i < 10000; i++) {
            count.incrementAndGet(); //count++
        }
    }

    public static void main(String[] args) {
        CAS01 c = new CAS01();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(c::m,"thread-"+i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try{
                o.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });
        System.out.println(c.count);
    }
}

性能比较

测试代码

package character03;

import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * @Author laimouren
 * @Date 2021/12/21 8:56
 */
public class AtomicVsSyncVsLongAdder {
    static long count2 = 0L;
    static AtomicLong count1 = new AtomicLong(0L);
    static LongAdder count3 = new LongAdder();

    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[10000];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                for (int k = 0;k < 10000;k++){
                    count1.incrementAndGet();
                }
            });
        }
        long start = System.currentTimeMillis();
        for (Thread t:threads) {
            t.start();
        }
        for (Thread t:threads) {
            t.join();
        }
        long end = System.currentTimeMillis();
        System.out.println("Atomic:"+count1.get()+"time"+(end - start));

        //-------------
        Object lock = new Object();
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                for (int k = 0;k < 10000;k++){
                    synchronized (lock){
                        count2++;
                    }
                }
            });
        }
        start = System.currentTimeMillis();
        for (Thread t:threads) {
            t.start();
        }
        for (Thread t:threads) {
            t.join();
        }
        end = System.currentTimeMillis();
        System.out.println("synchronized:"+count2+"time"+(end - start));
        //-------------------------
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                for (int k = 0;k < 10000;k++){
                    count3.increment();
                }
            });
        }
        start = System.currentTimeMillis();
        for (Thread t:threads) {
            t.start();
        }
        for (Thread t:threads) {
            t.join();
        }
        end = System.currentTimeMillis();
        System.out.println("LongAdder:"+count3.longValue()+"time"+(end - start));
    }
}

使用JDK8进行测试
执行时间：LongAdder比其他两个快非常多 Atomic 比 Synchronzied慢

LongAdder类

java为解决频繁修改一个变量的业务需求而产生的一个类
底层使用了分段锁（也是CAS操作）

ReentrantLock （可重入锁）

底层是CAS+AQS队列
必须最后unlock()
synchronized必须是可重入锁（比如父类持有这把锁，子类也必须可以访问），可自动解锁
ReentrantLock可以替代Synchronized

package character03;

import java.util.concurrent.TimeUnit;

/**
 * @author laimouren
 */
public class ReentrantLock01 {
    synchronized void m1(){
        for (int i = 0; i < 10; i++) {
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(i);
            if(i == 2){
                m2();
            }
        }
    }
    synchronized void m2(){
        System.out.println("m2...");
    }

    public static void main(String[] args) {
        ReentrantLock01 r = new ReentrantLock01();
        new Thread(r::m1).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //new Thread(r::m2).start();
    }
}

使用reentrantlock替代synchronized

synchronized是自动解锁的，而ReetrantLock是需要手动解锁的（在finally块里执行）

package character03;

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

/**
 * @author laimouren
 */
public class ReentrantLock02 {
    Lock lock = new ReentrantLock();
    void m1(){
        try{
            lock.lock(); //synchronized(this)
            for (int i = 0; i < 10; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i);
            }
        }
        catch (InterruptedException e){
                e.printStackTrace();
        }finally {
        	//手动解锁
            lock.unlock();
        }
    }


    void m2(){
        try{
            lock.lock();
            System.out.println("m2...");
        }finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        ReentrantLock02 r = new ReentrantLock02();
        new Thread(r::m1).start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        new Thread(r::m2).start();
    }
}

比synchronized强大之处

可以使用tryLock尝试锁定，不管锁定与否，方法都继续执行
可以根据tryLock的返回值来判定是否锁定
可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unLock的异常处理
可以使用lockInterruptibly()，对interrupt()方法做出相应操作，比如搭配interrupt()方法进行唤醒线程
lockInterruptibly使用：

package character03;

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

/**
 * @author laimouren
 */
public class ReentrantLock03 {
    public static void main(String[] args) {

        Lock lock = new ReentrantLock();

        Thread t1 = new Thread(()->{
            try{
                lock.lock();
                System.out.println("t1 start");
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                System.out.println("t1 end");
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        });
        t1.start();
        Thread t2 = new Thread(()->{
            try{
                //lock.lock()
                lock.lockInterruptibly();//可以对interrupt()做出响应
                System.out.println("t2 start");
                TimeUnit.SECONDS.sleep(5);
                System.out.println("t2 end");
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        });
        t2.start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        t2.interrupt();//打断线程2的等待
    }
}

ReentrantLock可以是公平锁，默认是非公平

线程处于一个等待队列中，后进来的线程先检查等待队列是否有线程，有就排队等待使用锁，不一定是循环输出
synchronized只能是非公平锁

package character03;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author laimouren
 */
public class ReentrantLock04 extends Thread{
    //参数为true表示是公平锁，对比输出结果，先来先执行
    private static ReentrantLock lock = new ReentrantLock(true);
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            lock.lock();
            try{
                System.out.println(Thread.currentThread().getName()+"获得锁");
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ReentrantLock04 r = new ReentrantLock04();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
}

CountDownLatch

CAS锁
可以简单理解为：倒数时间，时间到门栓就打开了，也就是锁释放了
利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了
可以在一个线程多次countdown

基本使用

package character03;

import java.util.concurrent.CountDownLatch;

/**
 * @author laimouren
 */
public class CountDownLatch01 {
    public static void main(String[] args) {
        usingCountDownLatch();
        usingJoin();
    }
    private static void usingCountDownLatch(){
        Thread[] threads = new Thread[100];
        //参数是代表从多少数字开始倒数
        CountDownLatch latch = new CountDownLatch(threads.length);
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
               	int result = 0;
                for (int j = 0; j < 10000; j++) {
                    result+=j;
                }
                //不停地倒数，倒数到0，则await()方法结束
                //原子操作，不需要用sync
                //可以在同一个线程多次执行countDown();
                latch.countDown();
            });
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        try{
            //简单理解该方法是上门栓，等倒数到0时，门栓打开
            latch.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("end latch");
    }
    public static void usingJoin(){
        Thread[] threads = new Thread[100];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                int result = 0;
                for (int j = 0; j < 10000; j++) {
                    result += j;
                }
            });
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }

        for (int i = 0; i < threads.length; i++) {
            try {
                threads[i].join();
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

CyclicBarrier

循环屏障
可以简单理解为一个栅栏，当多个线程同时访问时会推倒这个栅栏
也可以理解为满人了就发车，周而复始
通过它可以实现让一组线程等待至某个状态之后再全部同时执行

比如：每个写入线程执行完写数据操作之后，就在等待其他线程写入操作完毕。
当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了。

作用：限流（入口特别多，但是出口特别少，从而达到限制流量的作用）
实际开发用到的应该是Guava RateLimiter（谷歌做的限流类）

基本操作

package character03;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author laimouren
 */
public class CyclicBarrier01 {
    public static void main(String[] args) {

        //和下面操作一个意思
        CyclicBarrier barrier1 = new CyclicBarrier(20,()-> System.out.println("满人，发车"));

        //第一个参数表示集满多少个线程开始执行第二个参数的runnable操作
        CyclicBarrier barrier = new CyclicBarrier(20, new Runnable() {
            @Override
            public void run() {
                System.out.println("满人，发车");
            }
        });
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                try{
                    barrier.await();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }catch (BrokenBarrierException e){
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Phaser

读音：feise，翻译：阶段器

java多线程技术提供了Phaser工具类，Phaser表示“阶段器”，用来解决控制多个线程分阶段共同完成任务的情景问题。其作用相比CountDownLatch和CyclicBarrier更加灵活，例如有这样的一个题目：5个学生一起参加考试，一共有三道题，要求所有学生到齐才能开始考试，全部同学都做完第一题，学生才能继续做第二题，全部学生做完了第二题，才能做第三题，所有学生都做完的第三题，考试才结束。分析这个题目：这是一个多线程（5个学生）分阶段问题（考试考试、第一题做完、第二题做完、第三题做完），所以很适合用Phaser解决这个问题。
参考博客
遗传算法用到，其他时候基本不用
按照不同阶段对线程进行执行

ReadWriteLock（重点）

读锁（共享锁）、写锁（排它锁）

线程读内容时，只允许其他线程读，不能写
线程写内容时，其他线程不允许操作

读情况特别多，写情况特别少的时候特别推荐

基本操作

package character03;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author laimouren
 */
public class ReadWriteLock01 {
    static Lock lock = new ReentrantLock();
    private static int value;
    static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    static Lock readLock = readWriteLock.readLock();
    static Lock writeLock = readWriteLock.writeLock();
    public static void read(Lock lock){
        try{
            lock.lock();
            Thread.sleep(1000);
            System.out.println("read over");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public static void write(Lock lock,int v){
        try{
            lock.lock();
            Thread.sleep(1000);
            value = v;
            System.out.println("write over");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public static void main(String[] args){
       // Runnable readR = ()->read(lock);
        Runnable readR = ()->read(readLock);
        //Runnable writeR = ()->write(lock,new Random().nextInt());
        Runnable writeR = ()->write(writeLock,new Random().nextInt());
        for (int i = 0; i < 18; i++) {
            new Thread(readR).start();
        }
        for (int i = 0; i < 2; i++) {
            new Thread(writeR).start();
        }
    }
}

相对单一排它锁（如ReentrantLock），效率大大提高

Semaphore

信号量：是一种计数器，用来保护一个或者多个共享资源的访问。如果线程要访问一个资源就必须先获得信号量。如果信号量内部计数器大于0，信号量减1，然后允许共享这个资源；否则，如果信号量的计数器等于0，信号量将会把线程置入休眠直至计数器大于0.当信号量使用完时，必须释放。

作用：限流（可以结合车辆车道和收费站来理解）

操作

package character03;

import java.util.concurrent.Semaphore;

/**
 * @author laimouren
 */
public class Semaphore01 {
    public static void main(String[] args) {
        //允许一个线程同时执行
        Semaphore s = new Semaphore(1);
        //第二个参数是指定是否公平
        Semaphore s1 = new Semaphore(1,true);
        new Thread(()->{
            try{
                //获得锁许可，即信号量减一
                s.acquire();
                System.out.println("T1 running..");
                Thread.sleep(200);
                System.out.println("T1 running...");

            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
            	//释放锁，即信号量加一
                s.release();
            }
        }).start();
        new Thread(()->{
            try{
                s.acquire();
                System.out.println("T2 running..");
                Thread.sleep(200);
                System.out.println("T2 running...");
                s.release();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }).start();
    }
}

Exchanger

了解一下
作用：线程间交换数据
第一个线程执行exchange()时，阻塞；
第二个线程执行exchange()时，交换两个线程的消息；
然后都继续向下执行。

学而知不足~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC第三课——复习、ReentrantLock、CountDownLatch、CyclicBarrier、Phaser、ReadWriteLock、Semaphore、Exchanger

CAS复习类似乐观锁，是使用CPU的原语实现cas(期望值,更新值)例子：m = 0;m++;cas(0,1){for(;;)如果当前值==0 则m=1}AtomicXX类package character02;import java.util.ArrayList;import java.util.List;import java.util.concurrent.atomic.AtomicInteger;/** * 解决同样问题的更高效的方法，使用AtomXX类 * At
复制链接

扫一扫