From a7c6568e6ea177200507fc0ec910dc7773cb429a Mon Sep 17 00:00:00 2001 From: xiongraorao Date: Thu, 2 Aug 2018 15:58:10 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/raorao/java/thread/MyThread.java | 46 ++ .../java/thread/excutor/FutureTaskTest.java | 53 ++ .../raorao/java/thread/excutor/LockTest.java | 40 ++ .../java/thread/excutor/MyExecutor.java | 47 ++ interview/README.md | 5 +- interview/java/base.md | 311 +++++++++++- interview/java/img/TIM截图20180801171519.jpg | Bin 0 -> 13471 bytes interview/java/img/TIM截图20180801172104.jpg | Bin 0 -> 7901 bytes interview/java/thread.md | 480 ++++++++++++++++++ 9 files changed, 977 insertions(+), 5 deletions(-) create mode 100644 code/src/main/java/com/raorao/java/thread/MyThread.java create mode 100644 code/src/main/java/com/raorao/java/thread/excutor/FutureTaskTest.java create mode 100644 code/src/main/java/com/raorao/java/thread/excutor/LockTest.java create mode 100644 code/src/main/java/com/raorao/java/thread/excutor/MyExecutor.java create mode 100644 interview/java/img/TIM截图20180801171519.jpg create mode 100644 interview/java/img/TIM截图20180801172104.jpg diff --git a/code/src/main/java/com/raorao/java/thread/MyThread.java b/code/src/main/java/com/raorao/java/thread/MyThread.java new file mode 100644 index 00000000..9938614f --- /dev/null +++ b/code/src/main/java/com/raorao/java/thread/MyThread.java @@ -0,0 +1,46 @@ +package com.raorao.java.thread; + +import java.util.concurrent.Callable; +import java.util.concurrent.FutureTask; + +/** + * 线程类. + * + * @author Xiong Raorao + * @since 2018-08-01-15:40 + */ +public class MyThread extends Thread { + + public static void main(String[] args) { + Thread t1 = new MyThread(); + t1.start(); + Thread t2 = new Thread(new MyThread2()); + t2.start(); + Callable call = new MyCallable(); + FutureTask task = new FutureTask(call); + Thread t3 = new Thread(task); + t3.start(); + } + + @Override + public void run() { + System.out.println("线程运行中---------extends"); + } + + static class MyThread2 implements Runnable{ + + @Override + public void run() { + System.out.println("线程运行中------runnable"); + } + } + + static class MyCallable implements Callable{ + + @Override + public String call() throws Exception { + System.out.println("线程运行中------callable"); + return "call over!"; + } + } +} diff --git a/code/src/main/java/com/raorao/java/thread/excutor/FutureTaskTest.java b/code/src/main/java/com/raorao/java/thread/excutor/FutureTaskTest.java new file mode 100644 index 00000000..da985fab --- /dev/null +++ b/code/src/main/java/com/raorao/java/thread/excutor/FutureTaskTest.java @@ -0,0 +1,53 @@ +package com.raorao.java.thread.excutor; + +import afu.org.checkerframework.checker.igj.qual.I; +import com.raorao.java.thread.excutor.MyExecutor.MyRunnable; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.FutureTask; +import javax.sound.midi.Soundbank; +import org.omg.PortableServer.THREAD_POLICY_ID; + +/** + * futureTask测试. + * + * @author Xiong Raorao + * @since 2018-08-02-11:16 + */ +public class FutureTaskTest { + + public static void main(String[] args) throws ExecutionException, InterruptedException { + Integer result = 0; + FutureTask task1 = new FutureTask<>(new MyRunnable("future thread"), result); +// task1.run(); +// System.out.println(task1.get()); + +// FutureTask task2 = new FutureTask<>(new MyCallable(5)); +// task2.run(); +// System.out.println(task2.get()); + ExecutorService service = Executors.newFixedThreadPool(1); + Future res = service.submit(new MyCallable(5)); + System.out.println(res.get()); + System.out.println("ok"); + Thread.sleep(2000); + service.shutdown(); + } + + static class MyCallable implements Callable{ + + private Integer res = 0; + public MyCallable(Integer a) { + res = a; + } + + @Override + public Integer call() throws Exception { + //Thread.sleep(2000); + wait(2000); + return res * res; + } + } +} diff --git a/code/src/main/java/com/raorao/java/thread/excutor/LockTest.java b/code/src/main/java/com/raorao/java/thread/excutor/LockTest.java new file mode 100644 index 00000000..041a071d --- /dev/null +++ b/code/src/main/java/com/raorao/java/thread/excutor/LockTest.java @@ -0,0 +1,40 @@ +package com.raorao.java.thread.excutor; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.LockSupport; +import java.util.concurrent.locks.ReentrantLock; + +/** + * 可重入锁测试. + * + * @author Xiong Raorao + * @since 2018-08-02-11:14 + */ +public class LockTest { + + private Lock lock = new ReentrantLock(); + + public static void main(String[] args) { + LockTest test = new LockTest(); + ExecutorService service = Executors.newFixedThreadPool(3); + for(int i = 0 ; i < 3 ; i ++){ + service.submit(() -> test.func()); + } + + + } + + public void func() { + lock.lock(); + try { + for (int i = 0; i < 10; i++) { + System.out.print(i + " "); + } + } finally { + lock.unlock(); // 确保释放锁，从而避免发生死锁。 + } + } +} diff --git a/code/src/main/java/com/raorao/java/thread/excutor/MyExecutor.java b/code/src/main/java/com/raorao/java/thread/excutor/MyExecutor.java new file mode 100644 index 00000000..dc01d6b1 --- /dev/null +++ b/code/src/main/java/com/raorao/java/thread/excutor/MyExecutor.java @@ -0,0 +1,47 @@ +package com.raorao.java.thread.excutor; + +import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.FutureTask; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import javax.sound.midi.Soundbank; +import javax.sound.midi.Track; + +/** + * Executor框架. + * + * @author Xiong Raorao + * @since 2018-08-01-16:32 + */ +public class MyExecutor { + + public static void main(String[] args) { + ExecutorService service = Executors.newFixedThreadPool(3); + for(int i = 0; i < 3; i++){ + service.submit(new MyRunnable("thread-" + i)); + } + service.shutdown(); + } + + static class MyRunnable implements Runnable{ + + private String name; + + public MyRunnable(String name) { + this.name = name; + } + + @Override + public void run() { + System.out.println(name + " start ..."); + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println(name + " end ..."); + } + } +} diff --git a/interview/README.md b/interview/README.md index 4ca50266..aa3d5c51 100644 --- a/interview/README.md +++ b/interview/README.md @@ -28,7 +28,10 @@ Thoutworks | 内推 | | [内推链接](https://jinshuju.net/f/CcO2JA) 顺丰科技 | 网申 | 即日 -- 9.23日 | [招聘官网](http://campus.sf-tech.com.cn/campusRecruitment/Default.html?p=28668990421)
7月20日投了内推 多益网络 | 内推 |
  • 内推笔试第一批：8.11 10:00
  • 内推笔试第二批: 9.06 10:00 | [招聘官网](https://xz.duoyi.com/jobs/index.html?t=0)
    7月20日投了内推 好未来 | 提前批 | 8.19日截止 | [招聘官网](http://job.100tal.com/jobxq?jobId=510212759)
  • 7月24日投了 -腾讯 | 提前批/网申 |
  • 提前批：7.25-9.12
  • 提前批：7.25-9.14
  • 在线笔试：9.16-9.17
  • 面试：9.26开始| [招聘官网](https://join.qq.com/) +腾讯 | 提前批/网申 |
  • 提前批：7.25-9.12
  • 提前批：7.25-9.14
  • 在线笔试：9.16-9.17
  • 面试：9.26开始| [招聘官网](https://join.qq.com/) +抖音、头条 | 内推 | 8.1 - 12.31| [招聘官网](https://job.bytedance.com/campus/)
  • 8.2 投简历 +携程 | 内推 |
  • 内推：8.2 - 8.12
  • 网申 8.2 - 9.4 | [招聘官网](http://campus.ctrip.com) + ## 2. 面试记录 diff --git a/interview/java/base.md b/interview/java/base.md index 813950f4..5c173782 100644 --- a/interview/java/base.md +++ b/interview/java/base.md @@ -1,6 +1,26 @@ -# java基础 + -## HashMap和ConcurrentHashMap +- [HashMap ConcurrentHashMap](#hashmap-concurrenthashmap) +- [java this 和 super的用法](#java-this-和-super的用法) + - [this](#this) + - [super](#super) + - [super和this的异同：](#super和this的异同) +- [抽象类和接口](#抽象类和接口) +- [Synchronized 和 volitate区别](#synchronized-和-volitate区别) +- [异常](#异常) +- [String StringBuffer StringBuilder的区别](#string-stringbuffer-stringbuilder的区别) + - [运行速度：](#运行速度) + - [线程安全](#线程安全) + - [总结](#总结) +- [java 如何实现序列化](#java-如何实现序列化) +- [什么是cookie？Session和cookie有什么区别？](#什么是cookiesession和cookie有什么区别) +- [如何避免死锁](#如何避免死锁) +- [进程和线程区别](#进程和线程区别) +- [参考文档](#参考文档) + + + +# HashMap ConcurrentHashMap HashMap和ConcurrentHashMap的最主要的区别就是前者是线程不安全，后者是线程安全的。在不同的JDK版本中，区别也不一样 @@ -16,8 +36,291 @@ ConcurrentHashMap 不用segment,改成CAS+synchronized方法实现。 CAS 的含义是“我认为原有的值应该是什么，如果是，则将原有的值更新为新值，否则不做修改，并告诉我原来的值是多少” -参考文档： +# java this 和 super的用法 + +## this + +this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。 + +this 的用法主要有三种： + +- 普通的直接引用，this 相当于当前对象本身 +- 形参与成员名字重名，用this来区分 +- 引用构造函数 （**必须放在构造函数的第一行**） + +``` java +class Person { + private int age = 10; + public Person(){ + System.out.println("初始化年龄："+age); +} + public int GetAge(int age){ + this.age = age; + return this.age; + } +} +``` + +## super + +super 指的是自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。 + +super 也有三种用法： + +- 普通的直接引用 +- 子类中的成员变量或方法与父类中的成员变量或方法同名 +- 引用构造函数 + +``` java +class Country { + String name; + void value() { + name = "China"; + } +} + +class City extends Country { + String name; + void value() { + name = "Shanghai"; + super.value(); //调用父类的方法 + System.out.println(name); + System.out.println(super.name); + } + + public static void main(String[] args) { + City c=new City(); + c.value(); + } +} +``` + +**super 作为引用构造函数的时候，必须放在第一行** + +``` java +class Person { + public static void prt(String s) { + System.out.println(s); + } + + Person() { + prt("父类·无参数构造方法： "+"A Person."); + }//构造方法(1) + + Person(String name) { + prt("父类·含一个参数的构造方法： "+"A person's name is " + name); + }//构造方法(2) +} + +public class Chinese extends Person { + Chinese() { + super(); // 调用父类构造方法（1） + prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); + } + + Chinese(String name) { + super(name);// 调用父类具有相同形参的构造方法（2） + prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); + } + + Chinese(String name, int age) { + this(name);// 调用具有相同形参的构造方法（3） + prt("子类：调用子类具有相同形参的构造方法：his age is " + age); + } + + public static void main(String[] args) { + Chinese cn = new Chinese(); + cn = new Chinese("codersai"); + cn = new Chinese("codersai", 18); + } +} +``` + +## super和this的异同： + +super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） +this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句） +super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参） +this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名） +调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。 +super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。 +super()和this()均需放在构造方法内第一行。 +尽管可以用this调用一个构造器，但却不能调用两个。 +this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。 +this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。 +从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。 + + + + + +# 抽象类和接口 + +抽象类与接口： + +抽象类和抽象方法都使用 abstract 进行声明。抽象类一般会包含抽象方法，抽象方法一定位于抽象类中。 +抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。 + +接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。 +从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 +之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。 + +接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。 +接口的字段默认都是 static 和 final 的。 + +抽象类和接口的比较 + | | 抽象类 | 接口 + --- | ---| --- + 设计| IS-A, 满足里式替换原则| LIKE-A, 提供一个方法实现契约 + 使用| 单继承| 多实现 + 字段| 无限制| static or final + 方法| 无限制| public + +如何使用： + +使用抽象类： + +需要在几个相关的类中共享代码。 +需要能控制继承来的方法和域的访问权限，而不是都为 public。 +需要继承非静态（non-static）和非常量（non-final）字段。 + +使用接口： + +需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法； +需要使用多重继承，例如Runnable接口实现线程类 + +# Synchronized 和 volitate区别 + +[volatile与synchronized的区别](https://www.cnblogs.com/tf-Y/p/5266710.html) + +1) volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住. +2) volatile仅能使用在变量级别,synchronized则可以使用在变量,方法. +3) volatile仅能实现变量的修改可见性,而synchronized则可以保证变量的修改可见性和原子性.(**只能保证单个变量的读写原子性，不能保证volatile++这种复合操作的原子性**) +4) volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞. +5) 当一个域的值依赖于它之前的值时，volatile就无法工作了，如n=n+1,n++等。如果某个域的值受到其他域的值的限制，那么volatile也无法工作，如Range类的lower和upper边界，必须遵循lower<=upper的限制。 +6) 使用volatile而不是synchronized的唯一安全的情况是类中只有一个可变的域。 + +# 异常 + +Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： Error 和 Exception。其中 Error 用来表示 JVM 无法处理的错误，Exception 分为两种： + +受检异常 ：需要用 try...catch... 语句捕获并进行处理，并且可以从异常中恢复； +非受检异常 ：是程序运行时错误，例如除 0 会引发 Arithmetic Exception，此时程序奔溃并且无法恢复。 +![throwable](img/Throwable.png) + +[java入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception) + +# String StringBuffer StringBuilder的区别 + +## 运行速度： + +StingBuilder > StringBuffer > String + +String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的 + +``` java +String str = "abc"; +str = str + "de";// 原来的"abc"没了，下次GC会被回收掉，创建了一个新的str变量 + +``` + +## 线程安全 + +在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的 + +如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。 + +## 总结 + +String：适用于少量的字符串操作的情况 + +StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况 + +StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况 + + +# java 如何实现序列化 + +OutputStream.writeObject方法可以实现java对象的序列化，如果想要java自动实现，则需要实现Serializable接口 + +# 什么是cookie？Session和cookie有什么区别？ + +Cookie是会话技术,将用户的信息保存到浏览器的对象. + +区别： + +(1)cookie数据存放在客户的浏览器上，session数据放在服务器上 +(2)cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗,如果主要考虑到安全应当使用session +(3)session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，如果主要考虑到减轻服务器性能方面，应当使用COOKIE +(4)单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE不能3K。 + +结论： + +将登陆信息等重要信息存放为SESSION;其他信息如果需要保留，可以放在COOKIE中 + +# 如何避免死锁 + +死锁的发生必须满足以下四个条件： + +互斥条件：一个资源每次只能被一个进程使用。 + +请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 + +不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。 + +循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。 + +三种用于避免死锁的技术： + +加锁顺序（线程按照一定的顺序加锁） + +加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁） + +死锁检测 + +（死锁原因及如何避免更深理解移步：http://blog.csdn.net/ls5718/article/details/51896159） + +# 进程和线程区别 + +**定义：** + +进程：具有一定的独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立的单位 + +线程：进程的一个实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。 + +- 关系： + +一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行. + +相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。 + +- 区别： +进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。 + +1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. + +2) 线程的划分尺度小于进程，使得多线程程序的并发性高。 + +3) 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 + +4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 + +5) 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。 + +- 优缺点： +线程和进程在使用上各有优缺点： + +线程执行开销小，但不利于资源的管理和保护； + +而进程正相反。 + +同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。 + + +# 参考文档 - [HashMap? ConcurrentHashMap? 相信看完这篇没人能难住你！](https://crossoverjie.top/2018/07/23/java-senior/ConcurrentHashMap/) -- [Java多线程之CAS](https://blog.csdn.net/u010412719/article/details/52053390) \ No newline at end of file +- [Java多线程之CAS](https://blog.csdn.net/u010412719/article/details/52053390) + +- [Java中this和super的用法总结](https://www.cnblogs.com/hasse/p/5023392.html) \ No newline at end of file diff --git a/interview/java/img/TIM截图20180801171519.jpg b/interview/java/img/TIM截图20180801171519.jpg new file mode 100644 index 0000000000000000000000000000000000000000..301f36f06ebade5a47de01b0cca8cec09043a1cc GIT binary patch literal 13471 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

    %e;%Gi(8jwLupP*G-7}d4N{=Den19_X zoCKM__#mz6X_>O^lszU>*2T$%;HfR$;06ZYcWjUc5BmO_hW;DWI15h^?W4bJA7Vp- z`uogw**-^w-xfO=Vzz`7)4XOD_&jzPtyM+2k6MNv0hgRJ>MRe|&d1h6AE`vx026CEQIRT8KsJ$D-6|l(a{eJ2S)&Q4kUe8lty<{7VG^h_2odS8vFsFMCAEFMN+}IcM@dQGo;dsc>NZ4jdSH3I}qw;lTgP z)<%X?3|-z@)v|Z|uy|eC;=X@u+g=MC_+HZZQmdsC|1qJqGfkYAdt z#-Co3MbJQ(HdMU+V3`nEGt`hcMJk5X`u2yHeeAGo#iz~-H!-oyuT9PHI+C^zk3kt^ z1q%1NzC&F58BoTTv0Txyp$xQl-;$utm-rXG6LK;rb=1=;sREr-NI%&t@0uIlx>57w z{fwnu>VM13`q0dd30_%^zrEf)fg@D6cs$*fuOlo zj8;oOR1n*y?W^+JQg6ZVmn|0D@;{3TjiaGa!5cK=sD`^Z-q_i0TK z6U>X@-Aw{L;tYRVuo2dZSaE#&XB9J6ZZ>AHblhATs@*83q<#n=-+km9DOb@QWNIR3 z6XO^dlDPB0t@igi`M$=n__uz=tmmST+1y zKRcf8m==&UJW=Cl9SP}w(;DXg9Y-*{z>i;vobXUAX>x^#Jat;oFWcAHMp*k$)bEI1z@ZMo2%v}G< zDwRv`d}J}S$^TTZvVJgi!uCt0rAzXimzn}RA3$bmiJ#!h(sCa=NrnTa%waOI-=^3}Cg~!0Ax~5cRr!gE!}8E? zU0YB%{Fe0DIxqg>$E(L-WjaKKcb1-ZZig=5x$R0!qqaOiK*DAw50&H8 z-JceGH))}2VCW|yN9p{k1ycO!yqOaCifpV32jIYyvlF+#djeY_GDDlm?Vz_3i>0^X z+FPk&K+<9qmEIcTMeic+63MY=P4L0==deA*r1jV{6o*7;pJOZZ@##_=Iih#2cEJ3) zKAFVWv4*`*rF}KVCvF&@(6{KoW*l}J6vYiA%zjerZnUm%QMwrbW-?}Lu+0v}2x(xb z@^$Te!|iun<9@^+ZG)(l#j?tDGGM&~Lh0vVl!Ir)CK8=&s#1|}pQ~O3-6@Bzz2hqO zZ3A3AxaV7->E%bc8aC~NlekBIv{Sa+%ACmYDrH{}ieu0E%C06f>|12EdbWVA#ZBuF ziZY5#0=zgN^IfKE6ehHzfSSAJc@yyIwLdmf$&yj;dBcIzrjKbRi~h-8z2)`F&qi$RW6hkCDRZXg7`xZ`1?0=?rOgAg zmli=TR$KpSMv(N(HVWvQJ6c=%{nl$%=+;D5BI(_b97o)6?`QYrmTr*10gCpRP9gU1 ze1UW!&IV_`t>ybv?aUBj$pFG=%u<-Ul)5LW(ZAda8Ky*!kT;Q$)Si+p1cWHMJK^iP%{PITIaaSoNOzBcTya`~`sp1O4zoXJ!%`Yb7Jb*bxZ@Q65Ce2LOY z$xy**Gp$LDLd8Xye5#m!$Pi!ZjFd!SWt+L>TAv*Dl6QQebDWHaE^wr!&?i_Xqw1M3 z(P#v7$8xMziA|5HpHL0?q;*X)Pp%kO4M{8NZCe|qKl- + +- [CountDownLatch的用法](#countdownlatch的用法) +- [线程创建](#线程创建) +- [线程间协作](#线程间协作) + - [join](#join) + - [wait](#wait) + - [interrupt](#interrupt) + - [Condition](#condition) +- [Executor 框架](#executor-框架) + - [Executor 主要的类和接口](#executor-主要的类和接口) + - [ThreadPoolExecutor](#threadpoolexecutor) + - [newFixedThreadPool](#newfixedthreadpool) + - [newSingleThreadExecutor](#newsinglethreadexecutor) + - [newScheduledThreadPool](#newscheduledthreadpool) + - [newCachedThreadPool](#newcachedthreadpool) + - [Future 接口](#future-接口) + - [ScheduledThreadPoolExecutor](#scheduledthreadpoolexecutor) +- [参考文档](#参考文档) + + + +# CountDownLatch的用法 + +CountDownLatch 是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信。 + +如果想当前线程在别的线程执行完毕后执行，可以使用CountDownLatch。 + +``` java +/**

    Sample usage: Here is a pair of classes in which a group + * of worker threads use two countdown latches: + *

      + *
    • The first is a start signal that prevents any worker from proceeding + * until the driver is ready for them to proceed; + *
    • The second is a completion signal that allows the driver to wait + * until all workers have completed. + *
    + * + * 
     {@code
+ * class Driver { // ...
+ *   void main() throws InterruptedException {
+ *     CountDownLatch startSignal = new CountDownLatch(1);
+ *     CountDownLatch doneSignal = new CountDownLatch(N);
+ *
+ *     for (int i = 0; i < N; ++i) // create and start threads
+ *       new Thread(new Worker(startSignal, doneSignal)).start();
+ *
+ *     doSomethingElse();            // don't let run yet
+ *     startSignal.countDown();      // let all threads proceed
+ *     doSomethingElse();
+ *     doneSignal.await();           // wait for all to finish
+ *   }
+ * }
+ *
+ * class Worker implements Runnable {
+ *   private final CountDownLatch startSignal;
+ *   private final CountDownLatch doneSignal;
+ *   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
+ *     this.startSignal = startSignal;
+ *     this.doneSignal = doneSignal;
+ *   }
+ *   public void run() {
+ *     try {
+ *       startSignal.await();
+ *       doWork();
+ *       doneSignal.countDown();
+ *     } catch (InterruptedException ex) {} // return;
+ *   }
+ *
+ *   void doWork() { ... }
+ * }}
    + +``` + +# 线程创建 + +线程创建通常有3中方法： +- 继承 Thread 类 +- 实现 Runnable 接口 +- 实现 Callable 接口 + +实现 Runnable 接口来创建一个线程： + +``` java +public class MyThread extends Thread { + + public static void main(String[] args) { + Thread t1 = new MyThread(); + t1.start(); + Thread t2 = new Thread(new MyThread2()); + t2.start(); + Callable call = new MyCallable(); + FutureTask task = new FutureTask(call); + Thread t3 = new Thread(task); + t3.start(); + } + + @Override + public void run() { + System.out.println("线程运行中---------extends"); + } + + static class MyThread2 implements Runnable{ + + @Override + public void run() { + System.out.println("线程运行中------runnable"); + } + } + + static class MyCallable implements Callable{ + + @Override + public String call() throws Exception { + System.out.println("线程运行中------callable"); + return "call over!"; + } + } +} +``` + +# 线程间协作 + +## join + +在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。 + +对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。 + +``` java +public class JoinExample { + + public static void main(String[] args) { + JoinExample example = new JoinExample(); + example.test(); + } + private class A extends Thread { + @Override + public void run() { + System.out.println("A"); + } + } + + private class B extends Thread { + + private A a; + + B(A a) { + this.a = a; + } + + @Override + public void run() { + try { + a.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("B"); + } + } + + public void test() { + A a = new A(); + B b = new B(a); + b.start(); + a.start(); + } +} +``` + +## wait + +wait 方法会使得当前线程进入等待状态，使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。 + +wait() 和 sleep() 的区别 + +- wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法； +- wait() 会释放锁，sleep() 不会。 + +## interrupt + +线程中断的方法有两种： + +1. 使用 interrupted()来作为线程循环执行的判断条件 + +``` java +public class InterruptExample { + + private static class MyThread2 extends Thread { + @Override + public void run() { + while (!interrupted()) { + // .. + } + System.out.println("Thread end"); + } + } +} +``` + +2. 使用InterruptedException + +通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞 + +对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。 + +``` java +public class InterruptExample { + + private static class MyThread1 extends Thread { + @Override + public void run() { + try { + Thread.sleep(2000); + System.out.println("Thread run"); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } +} +public static void main(String[] args) throws InterruptedException { + Thread thread1 = new MyThread1(); + thread1.start(); + thread1.interrupt(); + System.out.println("Main run"); +} +``` + +## Condition + +java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。 + +``` java +public class AwaitSignalExample { + private Lock lock = new ReentrantLock(); + private Condition condition = lock.newCondition(); + + public void before() { + lock.lock(); + try { + System.out.println("before"); + condition.signalAll(); + } finally { + lock.unlock(); + } + } + + public void after() { + lock.lock(); + try { + condition.await(); + System.out.println("after"); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + lock.unlock(); + } + } +} +``` + +# Executor 框架 + +Executor 框架主要由3大部分组成，如下： + +![](img/TIM截图20180801171519.jpg) + +- 任务 + +被执行的任务需要实现 Runnable 或者 Callable接口 + +- 任务的执行 + +任务执行的核心接口 Executor, 以及继承自 Executor 的 ExecutorService 接口。 Executor 框架有两个关键类实现了 ExecutorService 接口(ThreadPoolExecutor 和 ScheduledThreadPoolExecutor) + +- 异步计算的结果 + +![](img/TIM截图20180801172104.jpg) + +Future 接口和 FutureTask 类 + +## Executor 主要的类和接口 + +类和接口 | 说明 +--- | --- +Executor | 一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command), Executor 框架的基础，它将任务的提交和任务的执行分离开来 +ExecutorService | 是一个比Executor使用更广泛的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法 +AbstractExecutorService | ExecutorService执行方法的默认实现 +ThreadPoolExecutor | 线程池的核心实现类，用来执行被提交的任务。通过调用Executors以下静态工厂方法来创建线程池并返回一个ExecutorService对象 +ScheduledExecutorService | 一个可定时调度任务的接口 +ScheduledThreadPoolExecutor | ScheduledExecutorService 的实现类， 可以在给定的延迟后运行命令，或者定期执行命令， 比 Timer更加灵活，功能更加强大。 + +### ThreadPoolExecutor + +ThreadPoolExecutor 使用 Executors来创建，提供了4种类型的ThreadPoolExectuor, 分别是 newFixedThreadPool 、 newSingleThreadExecutor 、newScheduledThreadPool、 newCachedThreadPool. + +- 构造函数 + +``` java +/** + * Creates a new {@code ThreadPoolExecutor} with the given initial + * parameters. + * + * @param corePoolSize the number of threads to keep in the pool, even + * if they are idle, unless {@code allowCoreThreadTimeOut} is set + * @param maximumPoolSize the maximum number of threads to allow in the + * pool + * @param keepAliveTime when the number of threads is greater than + * the core, this is the maximum time that excess idle threads + * will wait for new tasks before terminating. + * @param unit the time unit for the {@code keepAliveTime} argument + * @param workQueue the queue to use for holding tasks before they are + * executed. This queue will hold only the {@code Runnable} + * tasks submitted by the {@code execute} method. + * @param threadFactory the factory to use when the executor + * creates a new thread + * @param handler the handler to use when execution is blocked + * because the thread bounds and queue capacities are reached + * @throws IllegalArgumentException if one of the following holds:
    + * {@code corePoolSize < 0}
    + * {@code keepAliveTime < 0}
    + * {@code maximumPoolSize <= 0}
    + * {@code maximumPoolSize < corePoolSize} + * @throws NullPointerException if {@code workQueue} + * or {@code threadFactory} or {@code handler} is null + */ +public ThreadPoolExecutor(int corePoolSize, + int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue workQueue, + ThreadFactory threadFactory, + RejectedExecutionHandler handler) +``` + +**参数说明：** + +corePoolSize：核心线程数，如果运行的线程少于corePoolSize，则创建新线程来执行新任务，即使线程池中的其他线程是空闲的 + +maximumPoolSize:最大线程数，可允许创建的线程数，corePoolSize和maximumPoolSize设置的边界自动调整池大小： +corePoolSize <运行的线程数< maximumPoolSize:仅当队列满时才创建新线程 +corePoolSize=运行的线程数= maximumPoolSize：创建固定大小的线程池 + +keepAliveTime:如果线程数多于corePoolSize,则这些多余的线程的空闲时间超过keepAliveTime时将被终止 + +unit:keepAliveTime参数的时间单位 + +workQueue:保存任务的阻塞队列，与线程池的大小有关： + 当运行的线程数少于corePoolSize时，在有新任务时直接创建新线程来执行任务而无需再进队列 + 当运行的线程数等于或多于corePoolSize，在有新任务添加时则选加入队列，不直接创建线程 + 当队列满时，在有新任务时就创建新线程 + +threadFactory:使用ThreadFactory创建新线程，默认使用defaultThreadFactory创建线程 + +handle:定义处理被拒绝任务的策略，默认使用ThreadPoolExecutor.AbortPolicy,任务被拒绝时将抛出RejectExecutorException + +### newFixedThreadPool + +创建可重用且固定线程数的线程池，如果线程池中的所有线程都处于活动状态，此时再提交任务就在队列中等待，直到有可用线程；如果线程池中的某个线程由于异常而结束时，线程池就会再补充一条新线程。 + +``` java +public static ExecutorService newFixedThreadPool(int nThreads) { + return new ThreadPoolExecutor(nThreads, nThreads, + 0L, TimeUnit.MILLISECONDS, + //使用一个基于FIFO排序的阻塞队列，在所有corePoolSize线程都忙时新任务将在队列中等待 + new LinkedBlockingQueue()); +} +``` + +### newSingleThreadExecutor + +创建一个单线程的Executor，如果该线程因为异常而结束就新建一条线程来继续执行后续的任务 + +``` java +public static ExecutorService newSingleThreadExecutor() { + return new FinalizableDelegatedExecutorService + //corePoolSize和maximumPoolSize都等于，表示固定线程池大小为1 + (new ThreadPoolExecutor(1, 1, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue())); +} +``` + +### newScheduledThreadPool + +创建一个可延迟执行或定期执行的线程池 + +``` java +/** + * Creates a new {@code ScheduledThreadPoolExecutor} with the + * given core pool size. + * + * @param corePoolSize the number of threads to keep in the pool, even + * if they are idle, unless {@code allowCoreThreadTimeOut} is set + * @throws IllegalArgumentException if {@code corePoolSize < 0} + */ +public ScheduledThreadPoolExecutor(int corePoolSize) { + super(corePoolSize, Integer.MAX_VALUE, + DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, + new DelayedWorkQueue()); +} +``` + +使用 scheduledThread 来模拟心跳： + +``` java +public class HeartBeat { + public static void main(String[] args) { + ScheduledExecutorService executor = Executors.newScheduledThreadPool(5); + Runnable task = new Runnable() { + public void run() { + System.out.println("HeartBeat........................."); + } + }; + executor.scheduleAtFixedRate(task,5,3, TimeUnit.SECONDS); //5秒后第一次执行，之后每隔3秒执行一次 + } +} +``` + +### newCachedThreadPool + +创建可缓存的线程池，如果线程池中的线程在60秒未被使用就将被移除，在执行新的任务时，当线程池中有之前创建的可用线程就重用可用线程，否则就新建一条线程 + +``` java +public static ExecutorService newCachedThreadPool() { + return new ThreadPoolExecutor(0, Integer.MAX_VALUE, + 60L, TimeUnit.SECONDS, + //使用同步队列，将任务直接提交给线程 + new SynchronousQueue()); +} +``` + +例子： + +``` java +public class ThreadPoolTest { + public static void main(String[] args) throws InterruptedException { + ExecutorService threadPool = Executors.newCachedThreadPool();//线程池里面的线程数会动态变化，并可在线程线被移除前重用 + for (int i = 1; i <= 3; i ++) { + final int task = i; //10个任务 + TimeUnit.SECONDS.sleep(1); + threadPool.execute(new Runnable() { //接受一个Runnable实例 + public void run() { + System.out.println("线程名字： " + Thread.currentThread().getName() + " 任务名为： "+task); + } + }); + } + } +} + +``` + +输出：（为每个任务新建一条线程，共创建了3条线程） +线程名字： pool-1-thread-1 任务名为： 1 +线程名字： pool-1-thread-2 任务名为： 2 +线程名字： pool-1-thread-3 任务名为： 3 +去掉第6行的注释其输出如下：（始终重复利用一条线程，因为newCachedThreadPool能重用可用线程） +线程名字： pool-1-thread-1 任务名为： 1 +线程名字： pool-1-thread-1 任务名为： 2 +线程名字： pool-1-thread-1 任务名为： 3 + +### Future 接口 + +Future 接口和实现了Future接口的FutureTask类用来表示异步计算的结果。当我们把Runnable 或者 Callable 接口的实现类提交给ThreadPoolExecutor时，Exector会返回给FutureTask对象 + +### ScheduledThreadPoolExecutor + +ScheduledThreadPoolExecutor 继承自 ThreadPoolExecutor, 主要用来在给定的延迟后运行任务。 主要包含3个成员变量： + +- long: time ; 表示这个任务将要被执行的具体时间 +- long: sequenceNumber; 表示这个任务被添加到SheduledThreadPoolExecutor 中的序号 +- long：period; 表示任务执行的间隔周期 + +该类采用了DelyQueue，封装了一个优先队列，该队列会对队列中的SheduledFutureTask 进行排序。time小的会排在前面，如果time相同，则会比较sequenceNumber, 就是说如果两个任务的执行时间相同，谁先提交就谁先执行 + +# 参考文档 + +- [java并发编程--Executor框架](https://www.cnblogs.com/MOBIN/p/5436482.html) \ No newline at end of file