JUC笔记----并发开发尝试入门

最新推荐文章于 2024-06-10 12:19:23 发布

JJyu可及

最新推荐文章于 2024-06-10 12:19:23 发布

阅读量226

点赞数

分类专栏：研发管理 Java工程狮学习面试文章标签： java 多线程并发编程面试 juc

本文链接：https://blog.csdn.net/jjy19971023/article/details/114464182

版权

面试同时被 3 个专栏收录

55 篇文章 3 订阅

订阅专栏

Java工程狮学习

50 篇文章 1 订阅

订阅专栏

研发管理

48 篇文章 2 订阅

订阅专栏

JUC

java.util.concurrent

java.util.concurrent.atomic

java.util.concurrent.locks

Runnable 没有返回值，且效率比Callable效率更低

并发和并行

多线程操作同一个资源,并发,快速交替

多个人一起走是并行,多个线程同时执行.

Java真的可以开启线程嘛?开不了只有本地底层得C++开启线程

并发编程得本质:充分利用CPU的资源

线程状态

新建–>运行–>阻塞–>等待(死死等待)–>超时等待—>终止态

wait/sleep

来自不同的类

wait->Object类

sleep–>Thread类

关于锁的释放:wait会释放锁,sleep不释放锁,抱着锁睡

使用的范围:wait必须在同步代码块,sleep可以在任何地方睡

是否需要捕获异常:wait无,sleep需要.

Lock锁:

Synchronized:排队,不保证每人都能取到

Synchronized和Lock的区别

Synchronized内置java关键字,Lock是一个Java类
Synchronized无法判断获取锁的状态,Lock可以判断是否获取到了锁
Synchronized会自动释放锁,lock必须手动释放锁,如果不释放锁,死锁.
Synchronized线程会等,lock锁不一定会等待下去
Synchronized适合锁少量的代码同步问题,Lock适合锁大量的同步代码

真正的多线程开发,线程就是一个单独的资源类,有对应的属性和方法

@FunctionalInterface函数式接口,Lambda表达式

Lock接口

ReentrantLock可重入锁(公平锁先来后到,和非公平锁可以插队,默认非公平锁)

ReadLock读锁

WriteLock写锁

lock(),

锁是什么?

8锁现象

锁的是谁？

深刻理解锁

1、sychronized 锁的是方法的调用者也就是新建对象（类），两个方法用的是同一个锁，谁先拿到的谁先执行。普通方法（非同步）不受锁的影响。

2、static静态方法，static修饰的synchronized方法全局唯一，所得是Class模板

3、一个普通的同步方法，一个静态的同步方法

new this具体的一个

static class 模板

生产者和消费者问题，

Synchronized 和notify问题

线程之间的通信问题：

A，B两线程同时操作一个变量。通知和等待唤醒

等待—业务–通知

存在ABCD四个线程会存在什么问题？

防止虚假唤醒：线程会被唤醒，而不会被通知，中断或超时，等待应该在循环中，而非判断中

JUC版的生产者和消费者问题

Lock

condition 取代了对象监视器：精准的通知和唤醒线程。通过多个监视器精准唤醒。

await signal

集合类不安全

List不安全ConcurrentModificationException 并发修改异常，并发现ArrayList不安全

解决方案，Vector，Conllections.synchronizedList，CopyOnWriteArrayList。

CopyOnWrite写入时复制，COW。多个线程调用的适合，读取的时候，固定的，写入的时候覆盖操作，写入的时候避免覆盖造成数据问题。读写分离。

CopyOnWriteArrayList 和Vector相比，效率更高因为用的Lock锁

Set

Collections.synchchronizedSet

CopyOnWriteSet

HashSet底层是什么？是HashMap用map put值，map是无须的key是不变得。

HashMap

不安全，

map是这样用的嘛？工作中不用HashMap

默认等价于什么？

加载因子0.75、初始化容量16

ConcurrentHashMap（）

Conclections.synchronizedMap

Callable

Callable,有返回值可以抛出异常，方法不同，call方法

泛型得参数和返回值类型一样

new Thread(new Runnable()).start();
new Thread(new FutureTask<V>(Callable)).start();

通过Runnable得实现类，实现Callable被装载。

有缓存

结果会等待，会阻塞

常用辅助类

CountDownLatch减法计数器

countDownLatch.count()计数器-1 必须要执行任务得时候再使用

countDownLatch.await()计数器归0再执行下面操作

CyclicBarrier

加法计数器，

Lambda操作final变量。

Semaphore

信号量

acquire获得信号量

release释放许可证会将当前信号量释放，唤醒等待得进程。并发限流，空值线程量

读写锁ReadWriteLock

读可被多个线程同时读，写是独家去写得。

更加细粒度得控制，

独占锁一次被一个线程占有，共享锁多个线程共同占有

阻塞队列

写入：如果队列满了，就必须阻塞等待，

取：如果队列是空的，必须阻塞等待生产

阻塞队列：BlockingQueue

什么情况下使用阻塞队列：

多线程并发处理，线程池。

Deque双端队列

四组API：抛出异常（add队列已满异常，remove队列无元素异常，element查看队首元素），不会抛出异常有返回值（offer，poll，peek），阻塞等待（put，take，），超时等待（offer，poll）

SynchronousQueue同步队列

进去一个元素，必须取出来才能再放

不存储元素，put一个元素必须take取出来，不然不能再put

线程池

池化技术：事先准备好一些资源，有人要用就从池子里拿，有用的就拿，用完就还给池子

程序的运行：本质占用系统的资源，优化资源的技术，线程池，连接池，对象池。。。

好处：

1、降低资源的消耗

2、提高响应的速度

3、方便管理

线程复用，可以控制最大并发数，管理线程。

三大方法

Executors线程池工具类：建立单线程池，创建一个固定的线程池，创建一个可伸缩的线程池

使用线程池之后，用线程池创建。threadPool.execute()。结束线程池threadPool.shutdown()

ThreadPoolExecuter（）

7大参数

   public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
                              int maximumPoolSize,//最大线程池大小
                              long keepAliveTime,//超时了无人调用就会释放
                              TimeUnit unit,//超时的单位
                              BlockingQueue<Runnable> workQueue,//阻塞队列
                              ThreadFactory threadFactory,//线程工厂，创建线程的，一般不动
                              RejectedExecutionHandler handler//拒绝策略) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }