JUC并发编程基础（7）--多线程锁

最新推荐文章于 2023-06-18 20:51:31 发布

aMythhhhh

最新推荐文章于 2023-06-18 20:51:31 发布

阅读量99

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_42194397/article/details/125752942

版权

Java 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

List集合线程不安全

ArrayList线程不安全

因为add方法没有加入同步关键字或者加锁，所以多个线程进行add的时候会报异常错误。

解决方法：

Vector（这个里面的add加了synchronize关键字，但方法较为古老不常用）
```
List<String> list = new Vector<>();
```

Collections工具类(也比较古老)

List<String> list = Collections.synchronizedList(new ArrayList<>());

常用方法类：CopyOnWriteArrayList
```
List<String> list = new CopyOnWriteArrayList<>();
```
原理：写时复制技术

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZSnFh45f-1657633946598)(C:\Users\aMyth\AppData\Roaming\Typora\typora-user-images\image-20220629214523016.png)]$

HashSet线程不安全

解决办法：

CopyOnWriteArraySet

Set<String> set = new CopyOnWriteArraySet<>();

HashSet其实底层还是HashMap

HashMap线程不安全

解决方法：

ConcurrentHashMap

Map<String,String> map = new ConcurrentHashMap<>();

多线程锁

synchronized实现同步的基础

Java中的每一个对象都可以作为锁，具体表现为以下三种形式：

对于普通同步方法，锁的是当前实例对象
对于静态同步方法，锁的是当前类的Class对象
对于同步方法块，锁是Synchonized括号里配置的对象
普通方法没有锁

公平锁和非公平锁

非公平锁：

线程饿死
效率较高

公平锁：

阳光普照
效率相对较低

根据实际来选择公平还是非公平

public ReentrantLock(){
    sync = new NonfairSync();//无参构造
}

public ReentrantLock(boolean fair){
    sync = fair ? new FairSync() : new NonfairSync();
}

可重入锁

syncchionzed（隐）和Lock（显）

解释一：可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

这是可重入锁的概念描述。

解释二：可重入锁又称递归锁，是指同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提是锁对象得是同一个对象)，不会因为之前已经获取过锁还没有释放而阻塞。

这是可重入锁的一种表现方式，不代表说某段代码中的锁没有发生嵌套，这个锁就不是可重入锁。

死锁

两个或两个以上的线程在执行过程中，因为争夺资源而相互等待的过程，如果没有外力干涉，无法继续执行。

在这里插入图片描述

死锁实例

package com.amyth.JavaEE;

public class DeadLock {


    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        new Thread(() ->{
            synchronized (a){
                System.out.println("已经拿到a锁,试图获取锁b");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println("获取锁b");
                }
            }
        },"A").start();
        new Thread(() ->{
            synchronized (b){
                System.out.println("已经拿到b锁,试图获取锁a");
                synchronized (a){
                    System.out.println("获取锁a");
                }
            }
        },"B").start();
    }
}

已经拿到a锁,试图获取锁b
已经拿到b锁,试图获取锁a
(程序未终止)

产生死锁的原因

系统资源不足
进程运行推进顺序不合适
资源分配不当

验证是否是死锁

jps 类似linux ps -ef查看当前进程
jstack 查看当前堆栈追踪工具

Callable接口

创建线程的多种方式

继承Thread类
实现Runnable接口
Callable接口
线程池方式

使用目的：为了实现需要有返回结果的线程，和runnable接口主要有以下区别：

是否有返回值
是否抛出异常（runnable没有异常）
实现方法名称不同，一个是run 一个是call

现在Thread类的构造方法中没有Callable接口，那么就要找到一个类和Runnable和Callable接口都有关系，才能把它俩联系起来

Runnable接口中有一个实现类：FutureTask，构造方法中就有Callable，可以传递Callable

通过Futrure Task中的get方法可以拿到Callable接口的返回值。

FutureTask原理

FutureTask是JDK并发包为Future接口提供的一个实现，代表一个支持取消操作（cancel）的异步计算任务。

FutureTask相当于就是单开一个线程去执行，最后汇总结果。

FutureTask在计算完成之后不能再次计算（复用），因此要想重新计算，需要调用runAndReset()（只计算一次）

FutureTask是Future的实现类

Future就是对于具体的Runnable和Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果等

在FutureTask中，队列的实现是一个单向链表，它表示所有等待任务执行完毕的线程的集合。我们知道，FutureTask实现了Future接口，可以获取“Task”的执行结果，那么如果获取结果时，任务还没有执行完毕怎么办呢？那么获取结果的线程就会在一个等待队列中挂起，直到任务执行完毕被唤醒。

辅助类

CountDownLatch 减少计数

该辅助类的作用是提供一个计数器，满足一些需要计数为0条件才执行的任务。

例如：教室中6名同学（6个线程）在自习，需要全部离开教室，班长（main线程）才能锁门。

由于在一个主线程中创建多个线程，主线程可能在多个线程结束前提前结束，如果不进行判断是否6个线程都结束，就可能存在，主线程结束了，还有其它线程没结束的矛盾情况—班长锁门了，还有同学没出来，还是能离开教室，不合理！

有了计数器之后，给予一个初始值，通过执行其中的countDown方法，使得计数器-1，通过main线程调用await方法进入等到，醒来的条件是计数器为0。

循环栅栏 CyclicBarrier

作用跟CountDownLatch相反，这里是设置一个Barrier线程，在满足初始设置参数值之前，这个线程一直阻塞，一直等待。

比如七龙珠中的集齐七颗龙珠（需要满足的参数值）召唤神龙（Barrier线程），必须要使得七龙珠全部集齐，才能唤醒神龙，不然将一直await。

信号灯 Semaphore

信号灯主要有两个作用：

用于多个共享资源的互斥使用
控制并发线程的数量

可以看做是synchronized的加强版，控制线程的并发数量。

主要有两种操作：

acquire（获取）当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），
要么一直等下去，直到有线程释放信号量，或超时。
release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
 
/**
 * 
 * @Description: TODO(这里用一句话描述这个类的作用)  
 * 
 * 在信号量上我们定义两种操作：
 * acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），
 *             要么一直等下去，直到有线程释放信号量，或超时。
 * release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
 * 
 * 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
 */
public class SemaphoreDemo
{
  public static void main(String[] args)
  {
     Semaphore semaphore = new Semaphore(3);//模拟3个停车位
     
     for (int i = 1; i <=6; i++) //模拟6部汽车
     {
       new Thread(() -> {
          try 
          {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+"\t 抢到了车位");
            TimeUnit.SECONDS.sleep(new Random().nextInt(5));
            System.out.println(Thread.currentThread().getName()+"\t------- 离开");
          } catch (InterruptedException e) {
            e.printStackTrace();
          }finally {
            semaphore.release();
          }
       }, String.valueOf(i)).start();
     }
  }
}