> 多線程即在同一時間，可以做多件事情。
> 創建多線程有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()并不能啟動一個新的線程
