> 多线程即在同一时间，可以做多件事情。
> 创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类
# 线程概念
首先要理解进程(Processor)和线程(Thread)的区别
**进程**：启动一个`LOL.exe`就叫一个进程。 接着又启动一个`DOTA.exe`，这叫两个进程。
**线程**：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如"盖伦” 击杀“提莫”，**同时**“赏金猎人”又在击杀“盲僧”，这就是由多线程来实现的。
<br>
此处代码演示的是**不使用多线程**的情况：
只有在盖伦杀掉提莫后，赏金猎人才开始杀盲僧
Hero:
```
package charactor;
public class Hero {
public String name;
public float hp;
public int damage;
public void attackHero(Hero h) {
try {
// 为了表示攻击需要时间，每次攻击暂停1000毫秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
h.hp -= damage;
System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n", name, h.name, h.name, h.hp);
if (h.isDead())
System.out.println(h.name + "死了！");
}
public boolean isDead() {
return 0 >= hp ? true : false;
}
}
```
# 创建多线程-继承线程类
使用多线程，就可以做到盖伦在攻击提莫的**同时**，赏金猎人也在攻击盲僧
设计一个类KillThread **继承Thread**，**并且重写run方法**
启动线程办法： 实例化一个KillThread对象，并且调用其**start**方法
就可以观察到 赏金猎人攻击盲僧的**同时**，盖伦也在攻击提莫
KillThread ：
```
package multiplethread;
import charactor.Hero;
public class KillThread extends Thread {
private Hero h1;
private Hero h2;
public KillThread(Hero h1, Hero h2) {
super();
this.h1 = h1;
this.h2 = h2;
}
public void run() {
while (!h2.isDead()) {
h1.attackHero(h2);
}
}
}
```
TestThread2：
```
package multiplethread;
import charactor.Hero;
public class TestThread2 {
public static void main(String[] args) {
Hero garen = new Hero();
garen.name = "盖伦";
garen.hp = 616;
garen.damage = 50;
Hero teemo = new Hero();
teemo.name = "提莫";
teemo.hp = 300;
teemo.damage = 30;
Hero bh = new Hero();
bh.name = "赏金猎人";
bh.hp = 500;
bh.damage = 65;
Hero leesin = new Hero();
leesin.name = "盲僧";
leesin.hp = 455;
leesin.damage = 80;
KillThread killThread1 = new KillThread(garen, teemo);
killThread1.start();
KillThread killThread2 = new KillThread(bh, leesin);
killThread2.start();
}
}
```
# 创建多线程-实现Runnable接口
创建类Battle，实现Runnable接口
启动的时候，首先创建一个Battle对象，然后再根据该battle对象创建一个线程对象，并启动
```
Battle battle1 = new Battle(gareen,teemo);
new Thread(battle1).start();
```
battle1 对象实现了Runnable接口，所以有run方法，但是直接调用run方法，并不会启动一个新的线程。
必须，借助一个线程对象的start()方法，才会启动一个新的线程。
所以，在创建Thread对象的时候，把battle1作为构造方法的参数传递进去，这个线程启动的时候，就会去执行battle1.run()方法了。
Battle：
```
package multiplethread;
import charactor.Hero;
public class Battle implements Runnable {
private Hero h1;
private Hero h2;
public Battle(Hero h1, Hero h2) {
this.h1 = h1;
this.h2 = h2;
}
public void run() {
while (!h2.isDead()) {
h1.attackHero(h2);
}
}
}
```
TestThread3：
```
package multiplethread;
import charactor.Hero;
public class TestThread3 {
public static void main(String[] args) {
Hero garen = new Hero();
garen.name = "盖伦";
garen.hp = 616;
garen.damage = 50;
Hero teemo = new Hero();
teemo.name = "提莫";
teemo.hp = 300;
teemo.damage = 30;
Hero bh = new Hero();
bh.name = "赏金猎人";
bh.hp = 500;
bh.damage = 65;
Hero leesin = new Hero();
leesin.name = "盲僧";
leesin.hp = 455;
leesin.damage = 80;
Battle battle1 = new Battle(garen, teemo);
new Thread(battle1).start();
Battle battle2 = new Battle(bh, leesin);
new Thread(battle2).start();
}
}
```
# 创建多线程-匿名类
使用**匿名类**，继承Thread,重写run方法，直接在run方法中写业务代码
匿名类的一个好处是可以很方便的访问外部的局部变量。
前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了)
```
package multiplethread;
import charactor.Hero;
public class TestThread4 {
public static void main(String[] args) {
Hero garen = new Hero();
garen.name = "盖伦";
garen.hp = 616;
garen.damage = 50;
Hero teemo = new Hero();
teemo.name = "提莫";
teemo.hp = 300;
teemo.damage = 30;
Hero bh = new Hero();
bh.name = "赏金猎人";
bh.hp = 500;
bh.damage = 65;
Hero leesin = new Hero();
leesin.name = "盲僧";
leesin.hp = 455;
leesin.damage = 80;
// 匿名类
Thread t1 = new Thread() {
public void run() {
// 匿名类中用到外部的局部变量teemo，必须把teemo声明为final
// 但是在JDK7以后，就不是必须加final的了
while (!teemo.isDead()) {
garen.attackHero(teemo);
}
}
};
t1.start();
Thread t2 = new Thread() {
public void run() {
while (!leesin.isDead()) {
bh.attackHero(leesin);
}
}
};
t2.start();
}
}
```
# 创建多线程的三种方式
把上述3种方式再整理一下：
1. 继承Thread类
2. 实现Runnable接口
3. 匿名类的方式
注： 启动线程是start()方法，run()并不能启动一个新的线程
