Java之多线程 Java之多线程

Thread（耦合，不推荐）
Runnable（解耦，推荐）
Executors
ExecutorService
Callable
1. Thread概述 Thread类在使用的方法在JDK手册中有介绍，它实现了Runnable接口中的唯一方法run()， run方法是线程执行的主体，因此在使用的时候需要重写run()方法去定义线程需要执行的功能，并且自定义Thread类的子类。
线程的执行开始点是调用了Thread类中的start()方法，start方法中实际上是去调用重写的run方法，这样一个线程就开始执行了

文章图片
JDK手册中对两种创建和启动线程的例子

Thread构造方法：
Thread()
Thread(Runnable target)
Thread(Runnable target,String name)
Thread(String name)
Thread(ThreadGroup group,Runnable target)
【Java之多线程】Thread(ThreadGroup group,Runnable target,String name)
Thread(ThreadGroup group,Runnable target,String name, long stackSize)
Thread(ThreadGroup group,String name)

2. 继承Thread类创建运行线程 main线程的退出不影响自定义线程的运行
自定义线程类MyThread，使用默认线程名的构造方法：

public class MyThread extends Thread{
long minPrime;
public MyThread() {}
public void run() {
int cnt = 0;
while(cnt != 5) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
out.printf(" ThreadName[%s] myThread cnt:%d\n", super.getName(), cnt);
cnt++;
}
out.println("myThread exit@@@@@@@@");
}
}

2.1. 自定义线程先退出

文章图片

2.2. main线程先退出

文章图片

3. 关于线程的命名 3.1. 获取线程名 String getName();
在线程中使用方法：super.getName(); 因为Mythread是继承了父类Thread，supper也可以不写，但是是调用的Thread中的方法
在2中的线程没有对线程命名，默认是Thread-N（0，1，2，……，N），主线程的名字是Thread-main

3.2. 获取当前线程的引用来获取线程名 Thread类中的静态方法：static Thread currentThread();
这个静态方法返回当前线程的Thread对象引用，在线程中拿到了Thread对象就能调用getName()方法了
例：在main线程中不能直接按照3.1的方式来获取线程名，使用静态方法currentThread()来获取线程名。

文章图片

3.2. 自定义线程名我们也可以对每个线程自定义名字
3.2.1. 通过构造方法设置线程名
原理是Thread的构造方法除了空参构造方法，还可以加入线程名的构造方法
Thread(String name)

文章图片
Thread(String name)构造方法

3.2.2. 在启动线程之前设置线程名
void setName(String name)

文章图片

4. 线程休眠sleep static void sleep(long millis)毫秒级休眠 1000 = 1s
static void sleep(long millis, int nanos)纳秒级休眠 1/1000000000s = 1纳秒

文章图片
静态方法直接调用，休眠1s

文章图片
休眠1微秒

5. 实现Runnable接口创建启动线程(推荐使用) 该方式是使用Thread的构造函数：Thread(Runnable target)

参数是实现了Runnable接口抽象方法的一个子类
public class RunnableThread implements Runnable{

public RunnableThread() {}
public void run() {
int cnt = 0;
Thread thd = Thread.currentThread();
while(cnt != 5) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
out.printf(" ThreadName[%s] myThread cnt:%d\n", thd.getName(), cnt);
cnt++;
}
out.println("myThread exit@@@@@@@@");
}
}

文章图片

6. 继承Thread方式和实现Runnable接口方式对比

文章图片

7. 使用匿名内部类实现多线程复习一下内部类

前提：
要有继承或者接口实现

语法：
new 父类或者接口(){
重写抽象方法abstractMethd(){
}
}

7.1. 方式一：子类继承Thread，匿名子类

文章图片
其实就是子类继承Thread，子类匿名了

7.2. 方式二：实现Runnable接口

文章图片

7.3. 方式三：前2种方法的结合，匿名第二种方式的接口实现类

文章图片

8. 线程的状态

文章图片

9. 线程池 JDK5以前要使用线程池，开发人员需要用集合维护线程池：
常用ArrayList：

文章图片
旧的线程池做法

从JDK5开始，提供了内置线程池
Executors类提供了创建线程池功能，是一个工具类都是静态方法

线程池使用场景：

假如你要做一个服务器端，一直在后台运行不会退出重启等操作，那么线程池是一个很好的选择，它避免了频繁创建销毁线程的系统开销，而且当线程池中的线程运行结束，线程池会回收该线程资源让其阻塞等待下一次被激活
如果是非一直需要运行的后台服务器，则没有必要使用线程池，因为如果没有强行终止，线程池中的线程是会一直存在的，即便main线程退出也会存在

9.1. 使用Executors工具类创建线程池 Executors工具类中的方法创建线程池：static ExecutorService newFixedThreadPool(int nThreads)
参数nThreads：是要固定创建的线程数量
返回值ExecutorService：本身是一个接口，返回的是该接口实现类的对象

9.1.1 Future submit(Runnable task)
submit方法就是用来提交线程执行任务的，参数是Runnable接口的实现类
定义一个类SubThread实现Runnable接口中的run方法：

public class SubThread implements Runnable {

private String thdName = null;
private int intParam = 0;
public SubThread(String thdName, int param){
this.thdName = thdName;
this.intParam = param;
}
public void run() {
Thread thd = Thread.currentThread();
int cnt = 0;
thd.setName(thdName);
while(cnt != 5) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
out.printf("ThreadName[%s] thdN[%s] base[%d] myThread cnt:%d\n", thdName, thd.getName(), intParam, cnt);
cnt++;
}
out.println("myThread exit@@@@@@@@");
}
}

文章图片

9.1.2. 使用Callable创建线程池
Callable接口是一个跟Runnable功能类似的接口，但是功能比Runnable强大

文章图片
call方法 Callable接口中也只有一个方法来描述线程任务，类似于Runnable中的run方法，但是call方法有一个泛型返回值，且可以抛出异常，这是run方法做不到的

定义一个SubThreadCallable类：

import java.util.concurrent.Callable; public class SubThreadCallable implements Callable {

private String thdName = null;
private int intParam = 0;
public SubThreadCallable(String thdName, int param){
this.thdName = thdName;
this.intParam = param;
}
public Integer call() {
Thread thd = Thread.currentThread();
int cnt = 0;
thd.setName(thdName);
while(cnt != 5) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
out.printf("ThreadName[%s] thdN[%s] base[%d] myThread cnt:%d\n", thdName, thd.getName(), intParam, cnt);
cnt++;
}
out.println("subThread exit@@@@@@@@");
return cnt;
}
}

文章图片
从运行结果可以看出2行submit代码瞬间运行打印出main1，之后在Integer i1 = ft.get(); 这一行阻塞，使用Callable的实现类作为submit方法的参数，会等待所有线程获取到了返回值才会向下继续执行，但是线程是异步执行的，结果确是同步返回。
所以这种方式在main线程的最后一个返回值是阻塞的，跟python的线程很类似，改成异步锁效率更高，当释放一个线程就又使释放的线程又运行起来。
再不要求返回值的情况下，应该尽量采用Runnable这种方式。
改进版：