0、ThreadPo…JUC

是计算机中的程序关于某数据集合上的一次运行活动是系统进行资源分配和调度的基本单位是操作系统结构的基础。

在当代面向线程设计的计算机结构中进程是线程的容器。

程序是指令、数据及其组织形式的描述进程是程序的实体。

是计算机中的程序关于某数据集合上的一次运行活动是系统进行资源分配和调度的基本单位是操作系统结构的基础。

程序是指令、数据及其组织形式的描述进程是程序的实体。

线程thread

是操作系统能够进行运算调度的最小单位。

它被包含在进程之中是进程中的实际运作单位。

一条线程指的是进程中一个单一顺序的控制流一个进程中可以并发多个线程每条线程并行执行不同的任务。

总结来说:

进程指在系统中正在运行的一个应用程序程序一旦运行就是进程进程——资源分配的最小单位。

线程系统分配处理器时间资源的基本单元或者说进程之内独立执行的一个单元执行流。

线程——程序执行的最小单位。

1.3

串行表示所有任务都一一按先后顺序进行。

串行意味着必须先装完一车柴才能运送这车柴只有运送到了才能卸下这车柴并且只有完成了这整个三个步骤才能进行下一个步骤。

1.4.2

并行意味着可以同时取得多个任务并同时去执行所取得的这些任务。

并行模式相当于将长长的一条队列划分成了多条短队列所以并行缩短了任务队列的长度。

并行的效率从代码层次上强依赖于多进程/多线程代码从硬件角度上则依赖于多核

1.4.3

并发(concurrent)指的是多个程序可以同时运行的现象更细化的是多进程可以同时运行或者多指令可以同时运行。

但这不是重点在描述并发的时候也不会去扣这种字眼是否精确并发的重点在于它是一种现象,

CPU

来说同一时刻只能运行一个线程。

所以这里的同时运行表示的不是真的同一时刻有多个线程运行的现象这是并行的概念而是提供一种功能让用户看来多个程序同时运行起来了但实际上这些程序中的进程不是一直霸占

CPU

由于操作系统对进程的调度是随机的所以切分成多个小任务后可能会从任一小任务处执行。

这可能会出现一些现象

可能出现一个小任务执行了多次还没开始下个任务的情况。

这时一般会采用队列或类似的数据结构来存放各个小任务的成果

可能出现还没准备好第一步就执行第二步的可能。

这时一般采用多路复用或异步的方式比如只有准备好产生了事件通知才执行某个任务。

可以多进程/多线程的方式并行执行这些小任务。

也可以单进程/单线程执行这些小任务这时很可能要配合多路复用才能达到较高的效率

1.4.4

管程(monitor)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行JVM

中同步是基于进入和退出管程(monitor)对象实现的每个对象都会有一个管程(monitor)对象管程(monitor)会随着

java

对象一同创建和销毁执行线程首先要持有管程对象然后才能执行方法当方法完成之后会释放管程方法在执行时候会持有管程其他线程无法再获取同一个管程

1.6

修饰一个代码块被修饰的代码块称为同步语句块其作用的范围是大括号{}括起来的代码作用的对象是调用这个代码块的对象修饰一个方法被修饰的方法称为同步方法其作用的范围是整个方法作用的对象是调用这个方法的对象

synchronized

关键字而在子类中覆盖了这个方法在子类中的这个方法默认情况下并不是同步的而必须显式地在子类的这个方法中加上synchronized

关键字才可以。

当然还可以在子类方法中调用父类中相应的方法这样虽然子类中的方法不是同步的但子类调用了父类的同步方法因此子类的方法也就相当于同步了。

修改一个静态的方法其作用的范围是整个静态方法作用的对象是这个类的所有对象修改一个类其作用的范围是

synchronized

{System.out.println(Thread.currentThread().getName()

(number--)

修饰了当一个线程获取了对应的锁并执行该代码块时其他线程便只能一直等待等待获取锁的线程释放锁而这里获取锁的线程释放锁只会有两种情况

2线程执行发生异常此时

sleep方法被阻塞了但是又没有释放锁其他线程便只能干巴巴地等待试想一下这多么影响程序执行效率。

因此就需要有一种机制可以不让等待的线程一直无期限地等待下去比如只等待一定的时间或者能够响应中断通过

Lock

锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。

它们允许更灵活的结构可能具有非常不同的属性并且可能支持多个关联的条件对象。

Lock

synchronized

则必须要用户去手动释放锁如果没有主动释放锁就有可能导致出现死锁现象。

2.2.1

lock()方法是平常使用得最多的一个方法就是用来获取锁。

如果锁已被其他线程获取则进行等待。

Lock必须主动去释放锁并且在发生异常时不会自动释放锁。

因此一般来说使用

Lock

try{}catch{}块中进行并且将释放锁的操作放在finally

Lock

wait()/notify()这两个方法一起使用可以实现等待/通知模式

Lock

ReentrantLock意思是“可重入锁”关于可重入锁的概念将在后面讲述。

ReentrantLock

test.insert(Thread.currentThread());

}.start();

test.insert(Thread.currentThread());

}.start();

System.out.println(thread.getName()得到了锁);

for(int

System.out.println(thread.getName()释放了锁);

lock.unlock();

}一个用来获取读锁一个用来获取写锁。

也就是说将文件的读写操作分开分

ReadWriteLock

ReentrantReadWriteLock();public

static

{test.get(Thread.currentThread());};}.start();new

Thread(){public

{test.get(Thread.currentThread());};}.start();}

public

System.currentTimeMillis();while(System.currentTimeMillis()

start

{System.out.println(thread.getName()正在进行读操作);}System.out.println(thread.getName()读操作完毕);}

public

ReentrantReadWriteLock();public

static

{test.get(Thread.currentThread());};}.start();new

Thread(){public

{test.get(Thread.currentThread());};}.start();}

public

System.currentTimeMillis();while(System.currentTimeMillis()

start

{System.out.println(thread.getName()正在进行读操作);}System.out.println(thread.getName()读操作完毕);}

finally

如果有一个线程已经占用了读锁则此时其他线程如果要申请写锁则申请写

如果有一个线程已经占用了写锁则此时其他线程如果申请写锁或者读锁则

2.5

在性能上来说如果竞争资源不激烈两者的性能是差不多的而当竞争资源非常激烈时即有大量线程同时竞争此时

Lock

线程间通信的模型有两种共享内存和消息传递以下方式都是基本这两种模型来实现的。

我们来基本一道面试常见的题目来分析

场景—两个线程一个线程对当前数值加

0){this.wait();}number;System.out.println(--------

Thread.currentThread().getName()

加一成

0){this.wait();}number--;System.out.println(--------

Thread.currentThread().getName()

减一成

java.util.concurrent.locks.Condition;

import

java.util.concurrent.locks.Lock;

import

java.util.concurrent.locks.ReentrantLock;

class

0){condition.await();}number;System.out.println(--------

Thread.currentThread().getName()

加一成

number);condition.signalAll();}catch

(Exception

e){e.printStackTrace();}finally

减一*/public

0){condition.await();}number--;System.out.println(--------

Thread.currentThread().getName()

减一成

number);condition.signalAll();}catch

(Exception

e){e.printStackTrace();}finally

{lock.unlock();}}

java.util.concurrent.locks.Condition;

import

java.util.concurrent.locks.Lock;

import

java.util.concurrent.locks.ReentrantLock;

class

0){conditionA.await();}System.out.println(Thread.currentThread().getName()

A,第

e){e.printStackTrace();}finally

次*/public

1){conditionB.await();}System.out.println(Thread.currentThread().getName()

B,第

e){e.printStackTrace();}finally

次*/public

2){conditionC.await();}System.out.println(Thread.currentThread().getName()

C,第

{System.out.println(C);}System.out.println(-----------------------------------------);//开始打印

Anumber

e){e.printStackTrace();}finally

{lock.unlock();}}

秒TimeUnit.SECONDS.sleep(4);System.out.println(------sendSMS);}public

synchronized

{System.out.println(------sendEmail);}public

void

{System.out.println(------getHello);}

/**

其它的线程都只能等待换句话说某一个时刻内只能有唯一一个线程去访问这些

synchronized

当一个线程试图访问同步代码块时它首先必须得到锁退出或抛出异常时必须释放锁。

也就是说如果一个实例对象的非静态同步方法获取锁后该实例对象的其他非静态同步方

可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁

所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——类对象本身这两把锁是两个不同的对象所

但是一旦一个静态同步方法获取锁后其他的静态同步方法都必须等待该方法释放锁后才

能获取锁而不管是同一个实例对象的静态同步方法之间还是不同的实例对象的静态同

CallableFuture

call方法完成时结果必须存储在主线程已知的对象中以便主线程可

Future

InterruptedExceptionExecutionException

public

在主线程中需要执行比较耗时的操作时但又不想阻塞主线程时可以把这些

作业交给

方法而获取结果只有在计算完成时获取否则会一直阻塞直到任务转入完

成状态然后会返回结果或者抛出异常

{System.out.println(Thread.currentThread().getName()

run

{System.out.println(Thread.currentThread().getName()

call

方法,开始准备睡觉);Thread.sleep(1000);System.out.println(Thread.currentThread().getName()

(Exception

System.currentTimeMillis();}}public

static

MyThread2();//future-callableFutureTaskLong

futureTask2

futureTask2.get();System.out.println(result1);}//线程一new

}6.5

在主线程中需要执行比较耗时的操作时但又不想阻塞主线程时可以把这些

作业交给

时获取否则会一直阻塞直到任务转入完成状态然后会返回结果或者抛出异

只计算一次

中提供了三种常用的辅助类通过这些辅助类可以很好的解决线程数量过

Lock

java.util.concurrent.CountDownLatch;

/**

-{try{if(Thread.currentThread().getName().equals(同学

6)){Thread.sleep(2000);}System.out.println(Thread.currentThread().getName()

离开了);//计数器减一,不会阻塞countDownLatch.countDown();}catch

(Exception

休息System.out.println(主线程睡觉);countDownLatch.await();//全部离开后自动唤醒主线程System.out.println(全部离开了,现在的计数器为

}7.2

java.util.concurrent.CyclicBarrier;

/**

{if(Thread.currentThread().getName().equals(龙珠

号抢夺战开始,孙悟空开启超级赛亚人模式!);Thread.sleep(5000);System.out.println(龙珠

号!);}else{System.out.println(Thread.currentThread().getName()

收集到

了!!!!);}cyclicBarrier.await();}catch

(Exception

java.util.concurrent.Semaphore;

/**

{System.out.println(Thread.currentThread().getName()

找车位

ing);semaphore.acquire();System.out.println(Thread.currentThread().getName()

汽车停车成

e){e.printStackTrace();}finally

{System.out.println(Thread.currentThread().getName()

i).start();}}

现实中有这样一种场景对共享资源有读和写的操作且写操作没有读操作那么频繁。

在没有写操作的时候多个线程同时读一个资源没有任何问题所以应该允许多个线程同时读取共享资源但是如果一个线程想去写这些共享资源就不应该允许其他线程对该资源进行读和写的操作了。

针对这种场景JAVA

它表示两个锁一个是读操作相关的锁称为共享锁一个是写相关的锁称为排他锁

没有写请求,

或者有写请求但调用线程和持有锁的线程是同一个(可重入锁)。

线程进入写锁的前提条件

1公平选择性支持非公平默认和公平的锁获取方式吞吐量还是非公平优于公平。

3锁降级遵循获取写锁、获取读锁再释放写锁的次序写锁能够降级成为读锁。

8.3

ReentrantReadWriteLock();//放数据public

void

{//添加写锁rwLock.writeLock().lock();try

{System.out.println(Thread.currentThread().getName()

key);//暂停一会TimeUnit.MICROSECONDS.sleep(300);//放数据map.put(key,value);System.out.println(Thread.currentThread().getName()

key);}

{//释放写锁rwLock.writeLock().unlock();}}//取数据public

Object

{//添加读锁rwLock.readLock().lock();Object

result

{System.out.println(Thread.currentThread().getName()

key);//暂停一会TimeUnit.MICROSECONDS.sleep(300);result

map.get(key);System.out.println(Thread.currentThread().getName()

key);}

{//释放读锁rwLock.readLock().unlock();}return

result;}

在线程持有读锁的情况下该线程不能取得写锁(因为获取写锁的时候如果发现当前的读锁被占用就马上获取失败不管读锁是不是被当前线程持有)。

在线程持有写锁的情况下该线程可以继续获取读锁获取读锁时如果发现写锁被占用只有写锁没有被当前线程占用的情况才会获取失败。

原因:

当线程获取读锁的时候可能有其他线程同时也在持有读锁因此不能把获取读锁的线程“升级”为写锁而对于获得写锁的线程它一定独占了读写锁因此可以继续让它获取读锁当它同时获取了写锁和读锁后还可以先释放写锁继续持有读锁这样一个写锁就“降级”为了读锁

阻塞队列

“传输”数据的问题。

通过这些高效并且线程安全的队列类为我们快速搭建

BlockingQueue

试图从空的队列中获取元素的线程将会被阻塞直到其他线程往空的队列插入新的元素

试图向已满的队列中添加新元素的线程将会被阻塞直到其他线程从队列中移除一个或多

先进先出FIFO先插入的队列的元素也最先出队列类似于排队的功能。

后进先出LIFO后插入队列的元素最先出队列这种队列优先处理最近发

在多线程领域所谓阻塞在某些情况下会挂起线程即阻塞一旦条件满足被挂起

为什么需要

好处是我们不需要关心什么时候需要阻塞线程什么时候需要唤醒线程因为这一切BlockingQueue

concurrent

包发布以前在多线程环境下我们每个程序员都必须去自己控制这些细节尤其还要兼顾效率和线程安全而这会给我们的程序带来不小的复杂度。

多线程环境中通过队列可以很容易实现数据共享比如经典的“生产者”和

“消费者”模型中通过队列可以很便利地实现两者之间的数据共享。

假设我们有若干生产者线程另外又有若干个消费者线程。

如果生产者线程需要把准备好的数据共享给消费者线程利用队列的方式来传递数据就可以很方便地解决他们之间的数据共享问题。

但如果生产者和消费者在某个时间段内万一发生数据处理速度不匹配的情况呢理想情况下如果生产者产出数据的速度大于消费者消费的速度并且当生产出来的数据累积到一定程度的时候那么生产者必须暂停等待一下阻塞生产者线程以便等待消费者线程把累积的数据处理完毕反之亦然。

当队列中没有数据的情况下消费者端的所有线程都会被自动阻塞挂起直到有数据放入队列

当队列中填满数据的情况下生产者端的所有线程都会被自动阻塞挂起直到队列中有空的位置线程被自动唤醒

9.2

如果在指定时间内队列一旦有数据可取则立即返回队列中的数据。

否则知

take():

java.util.concurrent.ArrayBlockingQueue;

import

java.util.concurrent.BlockingQueue;

import

System.out.println(blockingQueue.add(a));

System.out.println(blockingQueue.add(b));

System.out.println(blockingQueue.add(c));

System.out.println(blockingQueue.element());

//System.out.println(blockingQueue.add(x));

System.out.println(blockingQueue.remove());

System.out.println(blockingQueue.remove());

System.out.println(blockingQueue.remove());

System.out.println(blockingQueue.remove());

第二组

System.out.println(blockingQueue.offer(a));

System.out.println(blockingQueue.offer(b));

System.out.println(blockingQueue.offer(c));

System.out.println(blockingQueue.offer(x));

System.out.println(blockingQueue.poll());

System.out.println(blockingQueue.poll());

System.out.println(blockingQueue.poll());

System.out.println(blockingQueue.poll());

第三组

System.out.println(blockingQueue.take());

System.out.println(blockingQueue.take());

System.out.println(blockingQueue.take());

System.out.println(blockingQueue.take());

第四组

System.out.println(blockingQueue.offer(a));

System.out.println(blockingQueue.offer(b));

System.out.println(blockingQueue.offer(c));

System.out.println(blockingQueue.offer(a,3L,

TimeUnit.SECONDS));

进而影响缓存局部性和整体性能。

而线程池维护着多个线程等待着监督管理者分配可并发执行的任务。

这避免了在处理短时间任务时创建与销毁线程的代价。

线程池不仅能够保证内核的充分利用还能防止过分调度。

年前单核

线程池做的工作只要是控制运行的线程数量处理过程中将任务放入队列然后在线程创建后启动这些任务如果线程数量超过了最大数量超出数量的线程排队等候等其他线程执行完毕再从队列中取出任务来执行。

它的主要特点为

降低资源消耗:

源还会降低系统的稳定性使用线程池可以进行统一的分配调优和监控。

Java

ExecutorServiceThreadPoolExecutor

这几个类

线程池中有三个重要的参数决定影响了拒绝策略corePoolSize

核心线

总结起来也就是一句话当提交的任务数大于workQueue.size()

maximumPoolSize

作用创建一个可缓存线程池如果线程池长度超过处理需要可灵活回收空闲线程若无可回收则新建线程.

特点:

Executors.defaultThreadFactory(),

new

ThreadPoolExecutor.AbortPolicy());

}场景:

适用于创建一个可无限扩大的线程池服务器负载压力较轻执行时间较短任务多的场景

10.3.2

作用创建一个可重用固定线程数的线程池以共享的无界队列方式来运行这些线程。

在任意点在大多数线程会处于处理任务的活动状态。

如果在所有线程处于活动状态时提交附加任务则在有可用线程之前附加任务将在队列中等待。

如果在关闭前的执行期间由于失败而导致任何线程终止那么一个新线程将代替它执行后续的任务如果需要。

在某个线程被显式地关闭之前池中的线程将一直存在。

创建方式

Executors.defaultThreadFactory(),

new

ThreadPoolExecutor.AbortPolicy());

}场景:

适用于可以预测线程数量的业务中或者服务器负载较重对线程数有严格限制的场景

10.3.3

Executor以无界队列方式来运行该线程。

注意如果因为在关闭前的执行期间出现失败而终止了此单个线程那么如果需要一个新线程将代替它执行后续的任务。

可保证顺序地执行各个任务并且在任意给定的时间不会有多个线程是活动的。

与其他等效的newFixedThreadPool

不同可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

线程池中最多执行

Executors.defaultThreadFactory(),

new

ThreadPoolExecutor.AbortPolicy());

}场景:

适用于需要保证顺序执行各个任务并且在任意时间点不会同时有多个线程的场景

10.3.4

ScheduledThreadPoolExecutor(corePoolSize,

threadFactory);

实现创建一个拥有多个任务队列的线程池可以减少连接数创建当前可用

cpu

ForkJoinPool.defaultForkJoinWorkerThreadFactory,

null,

Executors.defaultThreadFactory(),

new

ThreadPoolExecutor.DiscardOldestPolicy());

try

System.out.println(Thread.currentThread().getName()

窗口,开始卖票);

System.out.println(Thread.currentThread().getName()

窗口买票结束);

可以使得我们的任务单独运行在与主线程分离的其他线程中并且通过回调可

CompletableFuture

的接口抽象里面定义多种异步方法通过这两者集合从而打造出了强大的

CompletableFuture

里面通常用来表示一个异步任务的引用比如我们将任务提交到线程池里面然后我们会得到一个

Futrue在

方法可以一直阻塞直到任务结束然后获取结果但整体来说这种方式还是同步的因为需要客户端不断阻塞等待或者不断轮询才能知道任务是否完成。

Future

我提交了一个任务但是执行太慢了我通过其他路径已经获取到了任务结果现在没法把这个任务结果通知到正在执行的线程所以必须主动取消或者一直等待它执行完成

Future

方法会一直阻塞到任务完成但是想在获取任务之后执行额外的任务因为

Future