JUCJJJmk

JUC中的休息、暂停、sleep是TimeUnit.SECONDS.sleep()

java只能去调用本地方法开启线程，自身是开不了的

java无法操作硬件，他是运行在jvm虚拟机之上的

并行与并发

线程有几个状态

java中的sleep方法是thread.sleep(),而Python是time.sleep

但是在企业中一般不使用thread.sleep

而用

两者最主要的区别在于：sleep()方法没有释放锁，而wait()方法释放了锁。

两者都可以暂停线程的执行。

wait()通常被用于线程间交互/通信，sleep()通常被用于暂停执行。

wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者notifyAll()方法。sleep()方法执行完成后，线程会自动苏醒。或者可以使用wait(longtimeout)超时后线程会自动苏醒。

现在wait也需要捕获异常；

企业中开发多线程

模板：

这里reentrantlock又分为

如果一个线程要3小时一个，只要3分钟，那么用公平锁就要排队3小时

synchronize和lock锁区别

synchronized关键字修饰的代码相当于数据库上的互斥锁。确保多个线程在同一时刻只能由一个线程处于方法或同步块中，确保线程对变量访问的可见和排它，获得锁的对象在代码结束后，会对锁进行释放。

synchronzied使用方法有两个：①加在方法上面锁定方法，②定义synchronized块。

synchronized是Java中的关键字，是一种同步锁能够保证代码片段的原子性（也就是当同步代码块出现异常的时候，所有的操作都会回滚）和可见性但是不保证有序性。它修饰的对象有以下几种：

【注意】，synchronized是不能直接修饰变量的，会报错Modifier'synchronized'notallowedhere

但是可以通过同步代码块来修饰，举例：

这里很明显resource1的锁和resource2的锁不是同一把锁（因为得到是指定对象的锁，不管这个对象是不是static的所以这里的resource1的锁和resource2的锁是两个对象各自的锁），否则会出现可重入

privatestaticStringresource1="abc"privatestaticStringresource2="abc"//那么你下面获取resource1和source2就是同一个对象的锁，因为“abc”会被放到常量池中publicstaticvoidmain(String[]args){newThread(()->{synchronized(resource1){System.out.println(Thread.currentThread()+"getresource1");try{Thread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}System.out.println(Thread.currentThread()+"waitinggetresource2");synchronized(resource2){System.out.println(Thread.currentThread()+"getresource2");}}},"线程1").start();

publicvoidsynchronizedmethod（）{}

synchronized（mythread.class）{}，，例如：

在javaguide->并发编程->进阶篇->1.3

synchronized同步语句块的实现使用的是monitorenter和monitorexit指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置。

synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取得代之的确实是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法。

不过两者的本质都是对对象监视器monitor的获取。

首先synchronized获得锁的对象是根据修饰的不同而不同，一般分为对象和.class模板

而Lock的锁是来自其新建的newReentrantLock对象

1.synchronize是内置关键字，lock是java类

2.synchronize无法判断获取锁的状态，lock可以判断是否获得了锁

3.synchronize会自动释放锁（正常执行完程序或者抛异常都会自动释放），lock必须手动释放锁，不释放锁就会死锁

4.synchronize线程1（获得锁，阻塞）线程2（等待，傻傻的等）因为非公平锁；lock锁就不一定会等待下去，lock.trylock可以尝试获取锁

5.synchronize可重入锁，不可以中断，只能是非公平锁；lock。可重入锁，可以判断锁，非公平锁或者公平锁（可自己设置）

6.synchronize适合锁少量的同步代码，lock适合大量的同步代码。lock更灵活

7.synchronized关键字与wait()和notify()/notifyAll()方法（this.wait()和this.notify()）相结合可以实现等待/通知机制。ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition()方法。

锁是什么，如何判断锁是谁！

wait和notifyAll都是通过对象的this调用的

wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放），调用wait方法的一个或多个线程就会解除wait状态，重新参与竞争对象锁，程序如果可以再次得到锁，就可以继续向下运行。

1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

2）当前线程必须拥有此对象的monitor（即锁），才能调用某个对象的wait()方法能让当前线程阻塞，

（这种阻塞是通过提前释放synchronized锁，重新去请求锁导致的阻塞，这种请求必须有其他线程通过notify()或者notifyAll（）唤醒重新竞争获得锁）

3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；（线程去竞争）

（notify()或者notifyAll()方法并不是真正释放锁，必须等到synchronized方法或者语法块执行完才真正释放锁）

4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程，唤醒的线程获得锁的概率是随机的，取决于cpu调度

面试：单例模式、排序、生产者消费者、死锁问题

notifyall就是唤醒等待的线程

如果有ABCD4个线程：用以上方法可能存在虚假唤醒

把if判断改为while判断，因为多个线程都被唤醒了，很可能其中一个唤醒的线程，先一步改变的condition.此时另一个线程的condition已经不满足，因此需要加Where再次判断,参考下列代码和结果：

if唤醒之后不会再次判断，while唤醒之后会再次判断

新版：

Locklock=newReentrantLock();Conditioncondition=lock.newCondition();condition.await();//等待condition.signalALL());//唤醒全部condition优势

目前线程是随机状态执行

如何有序执行呢

8锁就是关于锁的8个问题

synchronize锁的对象是方法的调用者

1

.由于多线程是共享主线程的堆和方法区的，所以能够使用主线程的对象方法

2.hello方法没有锁

增加一个普通方法后，由于发短信延时4s，所以先执行hello再执行发短信

4.staticsynchronize静态方法，锁的对象是class模板，与对象无关。还是发短信优先。两个都是静态锁

5.普通同步和静态同步，一个锁对象，一个锁class模板，是两把锁

小结

普通同步锁，锁的是对象

静态同步锁，锁的是class模板

出现并发修改异常：ConcurrentModificationException

importjava.util.ArrayList;importjava.util.Collections;importjava.util.List;importjava.util.UUID;importjava.util.Vector;publicclassArrayListNotSafeDemo{publicstaticvoidmain(String[]args){Listlist=newArrayList<>();//Listlist=newVector<>();//Listlist=Collections.synchronizedList(newArrayList<>());for(inti=0;i<30;i++){newThread(()->{list.add(UUID.randomUUID().toString().substring(0,8));System.out.println(list);},String.valueOf(i)).start();}}}

List不安全

解决方案：1.是用Vector，这是安全的2.使用collection把集合变安全Collections.synchronizedList(newArrayList<>());

3.使用JUC下面的CopyOnWriteArrayList（写入时复制），这个比vector牛逼，因为vector使用synchronize而后者用的lock

Copyonwrite写入时复制COw计算机程序设计领域的一种优化策略;//多个线程调用的时候，List，读取的时候，固定的，写入（覆盖)在写入的时候避免覆盖，造成数据问题，是读写分离的

方案二：Collections.synchronized()采用Collections集合工具类，在ArrayList外面包装一层同步机制

上一节程序导致抛java.util.ConcurrentModificationException的原因解析

综上所述，假设线程A将通过迭代器next()获取下一元素时，从而将其打印出来。但之前，其他某线程添加新元素至list，结构发生了改变，modCount自增。当线程A运行到checkForComodification()，expectedModCount是modCount之前自增的值，判定modCount!=expectedModCount为真，继而抛出ConcurrentModificationException。方案三：

CopyOnWriteArrayList：写时复制，主要是一种读写分离的思想写时复制，CopyOnWrite容器即写时复制的容器，往一个容器中添加元素的时候，不直接往当前容器Object[]添加，而是先将Object[]进行copy，复制出一个新的容器object[]newElements，然后新的容器Object[]newElements里添加原始，添加元素完后，在将原容器的引用指向新的容器setArray(newElements)；这样做的好处是可以对copyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不需要添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器

publicbooleanadd(Ee){finalReentrantLocklock=this.lock;lock.lock();try{Object[]elements=getArray();intlen=elements.length;Object[]newElements=Arrays.copyOf(elements,len+1);newElements[len]=e;setArray(newElements);//讲原引用指向新的returntrue;}finally{lock.unlock();}

Set不安全

解决方法：①Collections.synchronizedSet(newHashSet<>())②CopyOnWriteArraySet<>()（推荐，这是JUC提供的）

hashset的底层就是hashmap，就是用了hashmap的key，因为key是不重复的

publicHashSet(){map=newHashMap<>();}//addset本质就是mapkey是无法重复的,这也就是为什么set是无序的，因为没法对key进行排序存储publicbooleanadd(Ee){returnmap.put(e,PRESENT)==null;//这里的PRESENT是一个常量newObject}privatestaticfinalobjectPRESENT=newobject();//不变得值!与list同理

HashMap不安全

解决方法：

重要：加载因子0.75和初始化容量16

原因：

我们知道hashmap的扩容因子是0.75，如果hashmap的数组长度已经使用了75%就会引起扩容，会新申请一个长度为原来两倍的桶数组，

然后将原数组的元素重新映射到新的数组中，原有数据的引用会逐个被置为null。就是在resize()扩容的时候会造成线程不安全。

另外当一个新节点想要插入hashmap的链表时，在jdk1.8之前的版本是插在头部，在1.8后是插在尾部。

那么hashmap什么时候进行扩容呢？当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，也就是说，默认情况下，数组大小为16，

那么当hashmap中元素个数超过160.75=12的时候，就把数组的大小扩展为216=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，

所以如果我们已经预知hashmap中元素的个数，那么预设数组的大小能够有效的提高hashmap的性能。

（1）在put的时候，因为该方法不是同步的，假如有两个线程A,B它们的put的key的hash值相同，不论是从头插入还是从尾插入，假如A获取了插入位置为x，

但是还未插入，此时B也计算出待插入位置为x，则不论AB插入的先后顺序肯定有一个会丢失；

（2）在扩容的时候，jdk1.8之前是采用头插法，当两个线程同时检测到hashmap需要扩容，在进行同时扩容的时候有可能会造成链表的循环，

主要原因就是，采用头插法，新链表与旧链表的顺序是反的，在1.8后采用尾插法就不会出现这种问题，同时1.8的链表长度如果大于8就会转变成红黑树。

1、可以有返回值2、可以抛出异常3、方法不同，run(/call)

线程启动的方式其实只有一个newThread().start();

代码测试

因为FutureTask里面的构造器能够接收callable，并且FutureTask是Runnable的实现类

使用FutureTask.get()获得callable的返回结果，get()方法可能会产生阻塞，等待结果的产生，或者使用异步通信，结果产生了才去拿，没产生就先执行后面的代码

细节：

1.有缓存

2.结果可能需要等待，会阻塞

这里其实就是只会有线程A执行，线程B不会执行，因为AB执行的是同一个对象，检测到futuretask已经执行过，就不会再执行了

下面的类都是AQS的组件

CountDownLatch（倒计时器）：CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。

如果不使用.await则会出现没有归0就closedoor的情况，使用之后必须归0才能关门，但是里面线程执行的顺序是不确定的

CyclicBarrier(循环栅栏)：CyclicBarrier和CountDownLatch非常类似，它也可以实现线程间的技术等待，但是它的功能比CountDownLatch更加复杂和强大。主要应用场景和CountDownLatch类似。CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

很明显线程是在await会执行+1操作，之后线程沉睡，然后，当到达7就会被唤醒，结束线程

也就是所有之前的线程都会等待知道最后一个线程出现才会同时进行

例子：抢车位6辆车抢3个车位

Semaphore.acquire():获得，假设已经满了，就会等待被释放

Semaphore.release():释放，会将当前信号量+1，然后唤醒等待的线程

作用:多个共享资源互斥的使用!并发限流，控制最大的线程数!

读可以被多个线程读，写只能被一个线程，读锁和写锁是互斥的马也就是读的时候不能写

读的时候也需要加锁这样能保证读的时候不能写入，就没有脏数据进来

ReadwriteLock

读-读可以共存!读-写不能共存!写-写不能共存!

这里会出现一个问题，某一个写完之后其实是可以允许读的，但是写的过程中不允许读

在java.util中有

blockingqueue是继承collection接口（又继承了iterable接口）的子接口，与list和set并列

Queue的实现类LinkedList

什么情况下我们会使用阻塞队列:多线程并发处理，线程池!

队列四组API

阻塞等待，是如果队列满了会等待，并且不会抛异常，没有返回值，会卡住

不存储元素，放入一个元素之后必须要先取出来，才能再放入，相当于等待的阻塞大小为1的队列

线程池：三大方法、7大参数，4种拒绝策略

池化技术

程序的运行，本质:占用系统的资源!优化资源的使用!=>池化技术线程池、jdbc连接池、内存池、对象池//因为创建和销毁十分浪费资源，所以只创建一次，然后将其保存起来，要用的时候就去拿，用完就放回来

池化技术︰事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处:

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

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

Executors是ThreadPoolExecutor的工具类（一般带有s的都是工具类），三大方法

//执行的时候threadPool.execute(()->{})

使用线程池之后使用线程池进行创建线程

1.newSingleThreadPool:方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

2.newFixedThreadPool:该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

3.newCacheThreadPool:该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。量的请求，从而导致OOM。

CachedThreadPool和ScheduledThreadPool：允许创建的线程数量为Integer.MAX_VALUE，可能会创建大量线程，从而导致OOM。

同理

源码分析

三个类底层都是调用的ThreadpoolExecutor

注意这里可伸缩线程最大是integer的值，是21亿，但是服务器不可能跑这么多，可能出现资源耗尽OOM，阿里规则建议使用ThreadpoolExecutor来创建

其中阻塞队列就是候客区，

正常创建：

privatestaticfinalintCORE_POOL_SIZE=5;privatestaticfinalintMAX_POOL_SIZE=10;privatestaticfinalintQUEUE_CAPACITY=100;privatestaticfinalLongKEEP_ALIVE_TIME=1L;publicstaticvoidmain(String[]args){//使用阿里巴巴推荐的创建线程池的方式//通过ThreadPoolExecutor构造函数自定义参数创建ThreadPoolExecutorexecutor=newThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME,TimeUnit.SECONDS,newArrayBlockingQueue<>(QUEUE_CAPACITY),newThreadPoolExecutor.CallerRunsPolicy());for(inti=0;i<10;i++){executor.execute(()->{try{Thread.sleep(2000);}catch(InterruptedExceptione){e.printStackTrace();}System.out.println("CurrentThreadname:"+Thread.currentThread().getName()+"date："+Instant.now());});}//终止线程池executor.shutdown();try{executor.awaitTermination(5,TimeUnit.SECONDS);}catch(InterruptedExceptione){e.printStackTrace();}System.out.println("Finishedallthreads");}

分析：核心线程池是永远会开的，其余的最大线程池减去核心线程池是当候客区已经满了，忙不过来的时候会开

所以12是核心线程池，12345是最大线程池，候客区就是阻塞队列,当候客区满了之后才回去开启最大线程里面的

人太多了，红色的也营业，

线程池最大承载是最大线程数+阻塞区

abortPolicy：不处理新进入的，并抛出异常

callerrunsPolicy：哪里来的去哪里，队列满了交给main线程处理，不会抛出异常

DiscartPolicy：任务满了就丢掉新的，不抛出异常

DiscartOldPolicy：把最前面的线程丢掉，执行最新的，不抛出异常

总结：拒绝新线程（1.抛出异常2.不抛出异常）交给main线程执行新的，丢掉最前面的

IO密集型（I/Obound）IO密集型指的是系统的CPU性能相对硬盘、内存要好很多，此时，系统运作，大部分的状况是CPU在等I/O(硬盘/内存)的读/写操作，此时CPULoading并不高。

计算密集型任务由于主要消耗CPU资源，因此，代码运行效率至关重要。Python这样的脚本语言运行效率很低，完全不适合计算密集型任务。对于计算密集型任务，最好用C语言编写。

cpu密集型（需要CPu运算的）：这个就直接吧线程数设置为cpu核数，用这个获取Runtime.getRuntime().availableProcessors()

io密集型：io是十分耗时的，比如15个大型任务，设置30个线程

新时代的程序员:lambda表达式、链式编程、函数式接口、Stream流式计算

Java中超级多FunctionInterface函数式接口

只要是函数式接口都可以用lambda表达式简化

函数式接口:只有一个方法的接口

例如：runnable接口

例如：foreach的中consumer参数

publicvoidforEach(Consumeraction){Objects.requireNonNull(action);finalintexpectedModCount=modCount;@SuppressWarnings("unchecked")finalE[]elementData=(E[])this.elementData;finalintsize=this.size;for(inti=0;modCount==expectedModCount&&i{voidaccept(Tt);defaultConsumerandThen(Consumerafter){Objects.requireNonNull(after);return(Tt)->{accept(t);after.accept(t);};}

Function函数型接口，有一个输入，有一个输出

注意，这里的T和R是指在这个泛型中会用到的两个东西，并不是特指后面的就是返回值

用lambda表达式简化

一个参数str，可以省略（）

输入值，返回布尔值

只有输入，没有返回值

@FunctionalInterfacepublicinterfaceConsumer{/***Performsthisoperationonthegivenargument.**@paramttheinputargument*/voidaccept(Tt);ArrayList