【JavaEE】锁策略 + synchronized原理 + CAS + JUC下常用类和接口 + 死锁

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadDemo30 {

    public static void main(String[] args) throws InterruptedException {

        AtomicInteger integer = new AtomicInteger(0);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 这个方法相当于自增
                integer.getAndIncrement();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                integer.getAndIncrement();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(integer);
    }

}

CAS在其中的作用就用这个自增方法举例。

在这个自增方法中其中初始的 V = 0(也就是我们设定的0)

想要自增时先要记录这个 V的值用 A 保存(有可能此时V就被其他线程修改了)。

自增的值为 B = V + 1;

要想把B赋值给V先要检查 A == V 就把B赋值给V(相等说明未被修改) : 就啥也不干(不相等说明V被修改了) 这一步是原子的不怕有线程安全问题

CAS中的ABA问题

ABA一个变量本来值为A然后变成了B最后又变成A的意思。

在CAS中当一个线程想要把B赋值给V时想要用A与V比较。

A这个变量是共享变量。有可能另外一个线程在比较之前把A变了然后又变回去了。

一般情况下这也不会出bug但是不排除极端情况。

解决方法是引入版本号。比如给A加个版本那么这时则是比较的A的版本号有无变化。

在Java中用AtomicStampedReference<V>来实现带有版本的功能。

JUC常用类和接口

JUC是java.util.concurrent的简称这个包下面大多是和多线程有关的类和接口。

线程池常用类和接口

已在这篇文章中详细介绍了。

【JavaEE】线程池_p_fly的博客-CSDN博客

原子类

在上述CAS问题中也介绍过了。

ReentrantLock类

这个类在java.util.concurrent.locks包中。

这个类的功能与synchronized关键字的功能很像。都是可重入互斥锁用来保证线程安全的。

构造方法

    // 默认构造方法创建的是非公平锁
    ReentrantLock lock1 = new ReentrantLock();
    // 带有boolean参数的构建方法可以设置是否为公平锁
    // true -- 公平    false -- 非公平
    ReentrantLock lock2 = new ReentrantLock(true);

实例方法

这里只介绍常用的实例方法

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

public class ThreadDemo31 {

    public static void main(String[] args) {
        ReentrantLock lock1 = new ReentrantLock();
        // 第一种加锁方式
        // 获取不到锁就一直等着
        lock1.lock();

        // 第二种加锁方式
        // 到了设定时间获取不到锁就放弃加锁
        try {
            lock1.tryLock(10, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 解锁  建议放到finally中
        // 因为有可能加完锁后执行不到解锁这个操作
        finally {
            lock1.unlock();
        }
    }

}

synchronized唤醒是通过Object类中的wait和notify来随机唤醒线程的

而reentrantlock唤醒是通过Condition类来指定唤醒某个线程的。

Semaphore类

这个类是把信号量封装起来了。信号量简单理解为可用资源的个数本质上是一个计数器。

信号量最重要的操作就是申请资源(P操作)和释放资源(V操作)。

可以设想一下火车票一趟火车的总票数就是可用资源。当有人买一张那么资源就少一个(P)当有人退票那么资源就会多一个(V)。如果总票数剩余为0要么候补有人退票要么放弃这趟火车另寻它车。

如果资源只有1个的时候它就变成了锁。拥有了锁也就把资源变成0了(资源不能为负数)释放了锁资源又变成1。

构造方法

        // 创建出有4个资源的信号量。获取资源是随机的
        Semaphore semaphore1 = new Semaphore(4);
        
        // 创建出10个资源的信号量。
        // true 尽可能是公平获取资源——先release的先获取(不是一定)
        // false 随机获取与第一种构造方法一样
        Semaphore semaphore2 = new Semaphore(10, true);

实例方法

这里只介绍P操作和V操作的方法。这些方法都是原子性的所以在多线程环境下可以使用。

                try {
                    // acquire() 表示获取资源
                    // 同时也要有异常  因为有可能没有资源这样就得阻塞等待
                    // 只要有阻塞一般都要有InterruptedException这个异常
                    semaphore1.acquire();
                    System.out.println("获取到一个资源");
                    // release() 表示释放资源
                    semaphore1.release();
                    System.out.println("释放一个资源");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

使用Semaphore来自增一个变量使用两个线程自增(保证线程安全)。

import java.util.concurrent.Semaphore;

class SemaphoreLock {
    private int n = 0;
    public Semaphore semaphore = new Semaphore(1);

    public void add (){
        n++;
    }

    public int getN() {
        return n;
    }

}

public class ThreadDemo33 {

    public static void main(String[] args) throws InterruptedException {

        SemaphoreLock lock = new SemaphoreLock();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    // 获取到资源后才能自增
                    lock.semaphore.acquire();
                    lock.add();
                    // 自增一次后就释放资源
                    lock.semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    lock.semaphore.acquire();
                    lock.add();
                    lock.semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(lock.getN());
    }

}

CountDownLatch类

通过下面的代码来理解这个类具体有什么作用。

构造方法

        // 创建三个定数器
        // 不能为负数否则会抛出异常
        CountDownLatch count = new CountDownLatch(3);

实例方法

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

public class ThreadDemo34 {

    public static void main(String[] args) throws InterruptedException {
        // 创建三个定数器(相当于三个选手)
        CountDownLatch count = new CountDownLatch(3);

        // t线程是跑步比赛的裁判
        Thread t = new Thread(() -> {
            try {
                // 这个方法会让 t 线程阻塞
                // 除非计数器被消耗光了才会解除阻塞
                count.await();

                // 这是另外一个会让 t 线程阻塞的方法
                // 有了时间的控制如果超过设定的时间还在阻塞就会解除阻塞
                // count.await(100, TimeUnit.MINUTES);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("跑步比赛已完成");
        });
        // t1/2/3线程是三位选手
        Thread t1 = new Thread(() -> {
            // 调用该方法计数器会减一
            count.countDown();
            System.out.println("t1比赛已完成");
        });
        Thread t2 = new Thread(() -> {
            count.countDown();
            System.out.println("t2比赛已完成");
        });
        Thread t3 = new Thread(() -> {
            count.countDown();
            System.out.println("t3比赛已完成");
        });
        t.start();
        //t.join();
        t1.start();
        t2.start();
        t3.start();
    }

}

Callable接口

这个接口和Runnable接口很像二者都是用来描述一个任务的。

不同之处①该接口可以返回一个结果不返回则会抛出异常。

②该接口实现的类不能直接放到Thread类的构造方法需要包装一下。

import java.util.concurrent.*;

public class ThreadDemo35 {

    public static void main(String[] args) {

        // 在t线程下计算1 + 1只要结果

        // 由于这个任务需要返回结果所用用Callable接口描述任务
        // 由于结果的整数所以用Integer类作为泛型参数
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 1 + 1;
            }
        };

        // 任务不能直接放到线程里工作
        // Thread t = new Thread(callable) 这样是不行的

        // 需要使用FutureTask包装以下
        // 这个类实现了Runnable接口所以可以放到Thread的构造方法中
        FutureTask<Integer> task = new FutureTask<>(callable);
        Thread t = new Thread(task);
        t.start();
        try {
            // get()方法是拿到结果
            System.out.println(task.get());
            // 结果不可能立刻出来(1+1还是可以立刻出来的)在没出来之前要进行阻塞等待
            // 阻塞就要有InterruptedException异常
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

}