企业官网建设流程全解析

5 多线程锁

5.1 锁的问题演示

classPhone{publicstaticsynchronizedvoidsendSMS()throwsException{//停留4秒//TimeUnit.SECONDS.sleep(4);System.out.println("------sendSMS");}publicsynchronizedvoidsendEmail()throwsException{System.out.println("------sendEmail");}publicvoidgetHello(){System.out.println("------getHello");}}

1. 标准访问，先打印短信还是邮件

------sendSMS

------sendEmail

2. 停 4 秒在短信方法内，先打印短信还是邮件

------sendSMS

------sendEmail

3. 新增普通的 hello方法，是先打短信还是 hello

------getHello

------sendSMS

4. 现在有两部手机，先打印短信还是邮件

------sendEmail

------sendSMS

5. 两个静态同步方法，1部手机，先打印短信还是邮件

------sendSMS

------sendEmail

6. 两个静态同步方法，2部手机，先打印短信还是邮件

------sendSMS

------sendEmail

7. 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件

------sendEmail

------sendSMS

8. 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件

------sendEmail

------sendSMS

5.2 结论

一个对象里面如果有多个 synchronized 方法，某一个时刻内，只要一个线程去调用其中的一个 synchronized 方法了， 其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些 synchronized 方法（因为在一个对象内的所有非静态 synchronized 方法使用的是同一把锁，锁的是当前对象 this，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized 方法）。

加个普通方法后发现和同步锁无关

换成两个对象后，就不是同一把锁了。

synchronized 实现同步的基础：Java 中的每一个对象都可以作为锁。

具体表现为以下 3 种形式。

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

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁， 可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——类对象本身，静态同步方法和非静态同步方法这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。

但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

6 Callable & Future 接口

6.1 Callable 接口

Runnable缺少的一项功能是，当线程终止时（即run()完成时），我们无法使线程返回结果。为了支持此功能，Java 中提供了Callable接口。

创建线程的第三种方案—Callable 接口.

6.1.1 Callable 接口的特点如下(重点)

• 实现 Runnable 接口时，需要实现不返回任何内容的run()方法；而对于Callable 接口，需要实现call()方法，并返回一个结果。
• call()</font>方法抛异常，而run()则不抛异常。

//创建新类 MyThread 实现 runnable 接口classMyThreadimplementsRunnable{@Overridepublicvoidrun(){}}//新类 MyThread2 实现 callable 接口classMyThread2implementsCallable<Integer>{@OverridepublicIntegercall()throwsException{return200;}}

6.2 Future 接口

当call()方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。

将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦 Callable 返回）。

Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下:

• public boolean cancel（boolean mayInterrupt）：用于停止任务。

如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true 时才会中断任务。

• public Object get（）抛出 InterruptedException，ExecutionException：用于获取任务的结果。 如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

• public boolean isDone（）：如果任务完成，则返回 true，否则返回 false。

可以看到 Callable 和 Future 做两件事-Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。实际上，future 也可以与 Runnable 一起使用。

要创建线程，需要 Runnable。为了获得结果，需要 future。

6.3 FutureTask

Java 库具有具体的FutureTask类型，该类型实现Runnable和Future，并方便地将两种功能组合在一起。 可以通过为其构造函数提供Callable来创建FutureTask。然后，将FutureTask对象提供给Thread的构造函数以创建Thread对象。因此，间接地使用Callable创建线程。

核心原理:(重点)

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成

• 当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态
• 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法
• 一旦计算完成，就不能再重新开始或取消计算
• get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常
• get 只计算一次,因此 get 方法放到最后

demo 案例

6.4 使用 Callable 和 Future

CallableDemo 案例

publicclassCallableDemo{/** 实现 runnable 接口 */staticclassMyThread1implementsRunnable{/** run 方法 */@Overridepublicvoidrun(){try{System.out.println(Thread.currentThread().getName()+"线程进入了 run 方法");}catch(Exceptione){e.printStackTrace();}}}/** 实现 callable 接口 */staticclassMyCallableimplementsCallable{/** call 方法 */@OverridepublicLongcall()throwsException{try{System.out.println(Thread.currentThread().getName()+"线程进入了 call 方法,开始准备睡觉");Thread.sleep(1000);System.out.println(Thread.currentThread().getName()+"睡醒了");}catch(Exceptione){e.printStackTrace();}returnSystem.currentTimeMillis();}}publicstaticvoidmain(String[]args)throwsException{//声明 runableRunnablerunable=newMyThread1();//声明 callableCallablecallable=newMyCallable();//future-callableFutureTask<Long>futureTask2=newFutureTask(callable);//线程二newThread(futureTask2,"线程二").start();for(inti=0;i<10;i++){Longresult1=futureTask2.get();System.out.println(result1);}//线程一newThread(runable,"线程一").start();}}

6.5 小结(重点)

• 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成, 当主线程将来需要时，就可以通过 Future 对象获得后台作业的计算结果或者执行状态
• 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果
• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。
• 只计算一次

7 JUC 三大辅助类

JUC 中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时 Lock 锁的频繁操作。这三种辅助类为：

• CountDownLatch: 减少计数
• CyclicBarrier: 循环栅栏
• Semaphore: 信号灯

7.1 减少计数 CountDownLatch

CountDownLatch类可以设置一个计数器，然后通过countDown方法来进行减 1 的操作，使用await方法等待计数器不大于 0，然后继续执行 await 方法之后的语句。

• CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞
• 其它线程调用countDown方法会将计数器减 1(调用countDown方法的线程不会阻塞)
• 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行

场景: 6 个同学陆续离开教室后值班同学才可以关门。

CountDownLatchDemo

publicclassCountDownLatchDemo{/** 6 个同学陆续离开教室后值班同学才可以关门 */publicstaticvoidmain(String[]args)throwsException{// 定义一个数值为 6 的计数器CountDownLatchcountDownLatch=newCountDownLatch(6);// 创建 6 个同学for(inti=1;i<=6;i++){newThread(()->{try{if(Thread.currentThread().getName().equals("同学 6")){Thread.sleep(2000);}System.out.println(Thread.currentThread().getName()+"离开了");// 计数器减一,不会阻塞countDownLatch.countDown();}catch(Exceptione){e.printStackTrace();}},"同学"+i).start();}// 主线程 await 休息System.out.println("主线程睡觉");// 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行countDownLatch.await();// 全部离开后自动唤醒主线程System.out.println("全部离开了,现在的计数器为"+countDownLatch.getCount());}}

7.2 循环栅栏 CyclicBarrier

CyclicBarrier看英文单词可以看出大概就是循环阻塞的意思，在使用中

CyclicBarrier的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加 1 操作场景: 集齐 7 颗龙珠就可以召唤神龙

publicclassCyclicBarrierDemo{//定义神龙召唤需要的龙珠总数privatefinalstaticintNUMBER=7;/** 集齐 7 颗龙珠就可以召唤神龙 */publicstaticvoidmain(String[]args){//定义循环栅栏CyclicBarriercyclicBarrier=newCyclicBarrier(NUMBER,()->{System.out.println("集齐"+NUMBER+"颗龙珠,现在召唤神龙!!!!!!!!!");});//定义 7 个线程分别去收集龙珠for(inti=1;i<=7;i++){newThread(()->{try{if(Thread.currentThread().getName().equals("龙珠 3 号")){System.out.println("龙珠 3 号抢夺战开始,孙悟空开启超级赛亚人模式!");Thread.sleep(5000);System.out.println("龙珠 3 号抢夺战结束,孙悟空打赢了,拿到了龙珠 3 号!");}else{System.out.println(Thread.currentThread().getName()+"收集到了!!!!");}cyclicBarrier.await();}catch(Exceptione){e.printStackTrace();}},"龙珠"+i+"号").start();}}}

7.3 信号灯 Semaphore

略。。

11 Fork/Join

11.1 Fork/Join 框架简介

Fork/Join它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。Fork/Join框架要完成两件事情：

Fork：把一个复杂任务进行分拆，大事化小

Join：把分拆任务的结果进行合并

1. 任务分割：首先 Fork/Join 框架需要把大的任务分割成足够小的子任务，如果子任务比较大的话还要对子任务进行继续分割
2. 执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里，启动一个线程从队列里取数据，然后合并这些数据。

在 Java 的Fork/Join框架中，使用两个类完成上述操作

• ForkJoinTask: 我们要使用 Fork/Join 框架，首先需要创建一个 ForkJoin 任务。该类提供了在任务中执行 fork 和 join 的机制。通常情况下我们不需要直接集成 ForkJoinTask 类，只需要继承它的子类，Fork/Join 框架提供了两个子类：

a.RecursiveAction：用于没有返回结果的任务

b.RecursiveTask:用于有返回结果的任务

• ForkJoinPool:ForkJoinTask 需要通过 ForkJoinPool 来执行
• RecursiveTask: 继承后可以实现递归(自己调自己)调用的任务

11.2 Fork/Join 框架的实现原理

ForkJoinPool 由 ForkJoinTask 数组和 ForkJoinWorkerThread 数组组成，

ForkJoinTask 数组负责将存放以及将程序提交给 ForkJoinPool，而 ForkJoinWorkerThread 负责执行这些任务。

11.2.1 Fork 方法

Fork 方法的实现原理：当我们调用 ForkJoinTask 的 fork 方法时，程序会把任务放在 ForkJoinWorkerThread 的 pushTask 的workQueue中，异步地

执行这个任务，然后立即返回结果

publicfinalForkJoinTask<V>fork(){Threadt;if((t=Thread.currentThread())instanceofForkJoinWorkerThread)((ForkJoinWorkerThread)t).workQueue.push(this);elseForkJoinPool.common.externalPush(this);returnthis;}

pushTask 方法把当前任务存放在 ForkJoinTask 数组队列里。然后再调用 ForkJoinPool 的 signalWork()方法唤醒或创建一个工作线程来执行任务。代码如下：

finalvoidpush(ForkJoinTask<?>task){ForkJoinTask<?>[]a;ForkJoinPoolp;intb=base,s=top,n;if((a=array)!=null){// ignore if queue removedintm=a.length-1;// fenced write for task visibilityU.putOrderedObject(a,((m&s)<<ASHIFT)+ABASE,task);U.putOrderedInt(this,QTOP,s+1);if((n=s-b)<=1){if((p=pool)!=null)p.signalWork(p.workQueues,this);}elseif(n>=m)growArray();}}

11.2.2 join 方法

Join 方法的主要作用是阻塞当前线程并等待获取结果。让我们一起看看

ForkJoinTask 的 join 方法的实现，代码如下：

publicfinalVjoin(){ints;if((s=doJoin()&DONE_MASK)!=NORMAL)reportException(s);returngetRawResult();}

它首先调用 doJoin 方法，通过 doJoin()方法得到当前任务的状态来判断返回什么结果，任务状态有 4 种：

已完成（NORMAL）、被取消（CANCELLED）、信号（SIGNAL）和出现异常（EXCEPTIONAL）

• 如果任务状态是已完成，则直接返回任务结果。
• 如果任务状态是被取消，则直接抛出 CancellationException
• 如果任务状态是抛出异常，则直接抛出对应的异常

让我们分析一下 doJoin 方法的实现

在 doJoin()方法流程如下:

1. 首先通过查看任务的状态，看任务是否已经执行完成，如果执行完成，则直接返回任务状态；
2. 如果没有执行完，则从任务数组里取出任务并执行。
3. 如果任务顺利执行完成，则设置任务状态为 NORMAL，如果出现异常，则记录异常，并将任务状态设置为 EXCEPTIONAL。

11.4 Fork/Join 框架的异常处理

ForkJoinTask 在执行的时候可能会抛出异常，但是我们没办法在主线程里直接捕获异常，所以ForkJoinTask 提供了 isCompletedAbnormally() 方法来检查任务是否已经抛出异常或已经被取消了，并且可以通过 ForkJoinTask 的 getException 方法获取异常。

getException 方法返回 Throwable 对象，如果任务被取消了则返回 CancellationException。如果任务没有完成或者没有抛出异常则返回 null。

11.5 入门案例

场景: 生成一个计算任务，计算 1+2+3…+1000, 每 100 个数切分一个子任务

/** 递归累加 */publicclassTaskExampleextendsRecursiveTask<Long>{privateintstart;privateintend;privatelongsum;//结果/** ● 构造函数 */publicTaskExample(intstart,intend){this.start=start;this.end=end;}@OverrideprotectedLongcompute(){System.out.println("任务"+start+"========="+end+"累加开始");//大于 100 个数相加切分,小于直接加if(end-start<=100){for(inti=start;i<=end;i++){//累加sum+=i;}}else{//切分为 2 块intmiddle=start+100;//递归调用,切分为 2 个小任务TaskExampletaskExample1=newTaskExample(start,middle);TaskExampletaskExample2=newTaskExample(middle+1,end);//执行:异步taskExample1.fork();taskExample2.fork();//同步阻塞获取执行结果sum=taskExample1.join()+taskExample2.join();}//加完返回returnsum;}}

/** * 分支合并案例 */publicclassForkJoinPoolDemo{/** ● 生成一个计算任务，计算 1+2+3.........+1000 */publicstaticvoidmain(String[]args){//定义任务TaskExampletaskExample=newTaskExample(1,1000);//定义执行对象ForkJoinPoolforkJoinPool=newForkJoinPool();//加入任务执行ForkJoinTask<Long>result=forkJoinPool.submit(taskExample);//输出结果try{System.out.println(result.get());}catch(Exceptione){e.printStackTrace();}finally{forkJoinPool.shutdown();}}}