前言
介绍Java的线程、线程池等操作

1、Java创建线程方式回顾
1.1、继承Thread类(只运行一次)
public class ThreadTest extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}

public static void main(String[] args) {
new ThreadTest().start();
}
}
1
2
3
4
5
6
7
8
9
10
1.1.1、改造成主线程常驻，每秒开启新线程运行

import java.util.Date;

@Slf4j
public class ThreadTest extends Thread{

@Override
public void run() {
log.info("线程名称：{} , 当前时间：{}" , Thread.currentThread().getName() , new Date().getTime() );
}

public static void main(String[] args) {

while (true) {
try {
new ThreadTest().start();
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
log.info("主线程常驻");
}
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1.1.2、匿名内部类
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ThreadTest extends Thread{

public static void main(String[] args) {

Thread thread = new Thread() {
@Override
public void run() {
log.info("Hello {}" , "world");
}
};

thread.start();
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1.1.3、缺点
继承了Thread类之后，就不能继承其他类

1.1.4、扩展知识：Java内部类
成员内部类（外部类内部使用，外部类外部使用）


import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Outer {
public static void main(String[] args) {
Inner inner = new Outer().initTest();
log.info(inner.innerTest());
}

public Inner initTest(){
Inner inner = new Inner();
return inner;
}

class Inner{
public Inner(){

}
public Inner(String s){

}

public String innerTest(){
return "Inner Hello world";
}
}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1.1.4.1、静态内部类
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Outer {
public static void main(String[] args) {
Inner inner = new Inner();
log.info(inner.innerTest());
}

public void initTest(){
Inner inner = new Inner();
}

static class Inner{
public Inner(){

}
public Inner(String s){

}
public String innerTest(){
return "Inner Hello world";
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1.1.4.2、匿名内部类
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Outer {
public static void main(String[] args) {
Outer outer = new Outer();
outer.sayHello();

}
public void sayHello(){
IMessage iMessage = new IMessage() {
//匿名类
@Override
public String sayHello() {
return "Hello world";
}
};
log.info(iMessage.sayHello());

}

interface IMessage{
String sayHello();
}

}


1.2、实现Runnable接口
1.2.1、普通类实现Runnable接口
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class StatSales implements Runnable{
@Override
public void run() {
log.info("统计销量");
}

public static void main(String[] args) {
Thread thread = new Thread() {
@Override
public void run() {
log.info("Hello world");
}
};
thread.start();
}
}


1.2.2、匿名方式创建Runnable实现类
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("统计成绩");
}
};
new Thread(runnable).start();
}

1.2.3、使用Lambda方式创建匿名Runnable类
// 使用 Lambda 匿名 Runnable 方式
Thread t3 = new Thread(() -> {
//添加业务方法…
});
// 启动线程
t3.start();

public static void main(String[] args) {
Thread thread = new Thread(() -> {
System.out.println("统计平均寿命");
});

thread.start();
}

1.2.4、缺点
不能获得程序的执行结果

1.2.5、扩展Lambda表达式
把函数作为一个方法的参数
表达式语法：

(parameters) -> expression

或

(parameters) ->{ statements; }

说明：

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
举例：

// 1. 不需要参数,返回值为 5
() -> 5

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y

// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

1.3、实现Callable接口
FutureTask+Callable

1.3.1、普通类实现Callable接口
public class StatScore implements Callable {
@Override
public Double call() throws Exception {
//统计分数的逻辑
return 88.98;
}
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
StatScore statScore = new StatScore();
//跟FutureTask 关联上
FutureTask doubleFutureTask = new FutureTask<>(statScore);
//跟Thread关联上
Thread thread = new Thread(doubleFutureTask);
thread.start();
log.info(String.valueOf(doubleFutureTask.get()));
}