一、实现多线程
多线程就是在同一时间做多件事情。
有3种方法实现多线程
一、实现Runnable接口
定义一个Hero类，有name，hp，damage属性，和一个attack行为
public class Hero { public String name; public float hp; public int damage; public void attack(Hero h) { try { //为了表示攻击过程 睡眠1000 Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } h.hp=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; } }
实现Runnable接口，接口中有个抽象的run()方法
public class Battle implements Runnable { private Hero h1; private Hero h2; public Battle(Hero h1,Hero h2) { this.h1 = h1; this.h2 = h2; } @Override public void run() { while(!h2.isDead()){ h1.attack(h2); } } }
二、继承Thread（其实Thread也是实现的Runnable接口）
public class KilledThread extends Thread{ private Hero h1; private Hero h2; public KilledThread(Hero h1,Hero h2) { this.h1 = h1; this.h2 = h2; } public void run() { while(!h2.isDead()) { h1.attack(h2); } } }
三、匿名类
//4、匿名类 Thread t1 = new Thread() { public void run() { //匿名类中用到外部的局部变量teemo，必须把teemo声明为final //但是在JDK7以后，就不是必须加final的了 while(!teemo.isDead()) { gareen.attack(teemo); } } }; Thread t2 = new Thread() { public void run() { while(!leesin.isDead()) { bh.attack(leesin); } } };
Test类
实例4个英雄 盖伦，赏金猎人，提莫，盲僧，分别用不使用多线程和3种实现多线程的方法，让盖伦打提莫，赏金猎人打盲僧
注意：run方法并不会启动线程，还需要调用start方法。
public class ThreadTest { public static void main(String[] args) { Hero gareen = new Hero(); gareen.name = "盖伦"; gareen.hp = 616; gareen.damage = 65; 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 = 300; leesin.damage = 80; /*1、未开启多线程 * //盖伦攻击提莫 while(!teemo.isDead()){ gareen.attack(teemo); } //赏金猎人攻击盲僧 while(!leesin.isDead()){ bh.attack(leesin); } */ /* 2、 继承Thread实现多线程 KilledThread kt1 = new KilledThread(gareen, teemo); kt1.start(); KilledThread kt2 = new KilledThread(bh, leesin); kt2.start(); */ /*3、 //实现Runnable实现多线程，其实Thread也是实现了Runnable Battle b1 = new Battle(gareen, teemo); //实现Runnable只有run方法，没有开启线程的start方法 //所以得借助Thread对象去调用start方法 new Thread(b1).start(); Battle b2 = new Battle(bh, leesin); new Thread(b2).start(); */
二、常用的线程方法
join
主线程就是，所有进程都至少会有一个线程即是主线程，main方法执行就会有一个看不见的主线程存在。将线程加入主线程，主线程会等待该线程结束才会继续运行下去。
setPriority
线程优先级：当线程处于竞争关系，优先级高的线程将会获得更多的cpu资源。最高的优先级：Thread.MAX_PRIORITY 最低的优先级：Thread.MIN_PRIORITY
setDaemon
守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。
就好像一个公司有销售部，生产部这些和业务挂钩的部门。
除此之外，还有后勤，行政等这些支持部门。
如果一家公司销售部，生产部都解散了，那么只剩下后勤和行政，那么这家公司也可以解散了。
守护线程就相当于那些支持部门，如果一个进程只剩下守护线程，那么进程就会自动结束。
守护线程通常会被用来做日志，性能统计等工作。
三、多线程会遇到的问题
新建一个Hero，定义2个方法，一个hp-1，一个hp+1
public class Hero { public String name; public float hp; public int damage; //回血 public void recover(){ hp=hp+1; } //掉血 public void hurt(){ hp=hp-1; } public void attackHero(Hero h) { 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; } }
测试类，实例化一个Hero，hp尽量大一些，用加血和减血线程同时执行10000次
public class TestThread { public static void main(String[] args) { final Hero gareen = new Hero(); gareen.name = "盖伦"; gareen.hp = 10000; System.out.printf("盖伦的初始血量是 %.0f%n", gareen.hp); int n = 10000; Thread[] addThreads = new Thread[n]; Thread[] reduceThreads = new Thread[n]; for (int i = 0; i < n; i++) { Thread t = new Thread(){ public void run(){ gareen.recover(); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }; t.start(); addThreads[i] = t; } //n个线程减少盖伦的hp for (int i = 0; i < n; i++) { Thread t = new Thread(){ public void run(){ gareen.hurt(); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }; t.start(); reduceThreads[i] = t; } //等待所有增加线程结束 for (Thread t : addThreads) { try { t.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //等待所有减少线程结束 for (Thread t : reduceThreads) { try { t.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量变成了 %.0f%n", n,n,gareen.hp); } }
最后理论上结果还是10000，但是实际上可能会出现10001或者9999等的结果。这种数据就叫做脏数据，是不准确的数据。
原因是：可能增加血量进程还未修改hp时，减少血量进程过来了，导致hp的值出现错误
解决办法：当一个进程修改hp时，其他进程不能访问hp
采用：synchronized 同步对象
1、可以在线程的匿名类run方法中加synchronized
2、将hero对象改为synchronized
3、将hero的hurt和recover方法用synchronized修饰
采用第一种方法的代码：
public class ThreadTest { public static void main(String [] args) { final Hero gareen = new Hero(); //为synchronized创建Object对象 final Object someObject = new Object(); gareen.name="盖伦"; gareen.hp=100000; System.out.printf("盖伦的初始血量是 %.0f%n", gareen.hp); //建立10000个线程线程减血，一次1点 int n=10000; Thread[] reduceThreads = new Thread[n]; for(int i=0;i<n;i++) { Thread t = new Thread() { public void run() { synchronized (someObject) { gareen.hurt(); } try { Thread.sleep(10); } catch (Exception e) { // TODO: handle exception } } }; t.start(); reduceThreads[i] = t; } //建立n个线程回血，每次回1 Thread[] addThreads = new Thread[n]; for(int i=0;i<n;i++) { Thread t = new Thread() { public void run() { //采用synchronized，任何修改hp需先占有一个someObject synchronized (someObject) { gareen.recover(); } try { Thread.sleep(10); } catch (Exception e) { // TODO: handle exception } } }; t.start(); addThreads[i] = t; } //等待所有增加线程结束 for (Thread t : addThreads) { try {//join将当前线程加入主线程 t.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //等待所有减少线程结束 for (Thread t : reduceThreads) { try { t.join(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量变成了 %.0f%n", n,n,gareen.hp); } }
四、线程池的使用
每一个线程的启动和结束都是比较消耗时间和占用资源的。
如果在系统中用到了很多的线程，大量的启动和结束动作会导致系统的性能变卡，响应变慢。
为了解决这个问题，引入线程池这种设计思想。
使用java自带线程池
public class ThreadPoolTest { public static void main(String[] args) { ThreadPoolExecutor tpe = new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()); for(int i = 0;i<20;i++) { tpe.execute(new Runnable() { @Override public void run() { System.out.println("任务"+Thread.currentThread().getName()); } }); } } }
其中new ThreadPoolExecutor（）方法中
第一个参数10 表示这个线程池初始化了10个线程在里面工作
第二个参数15 表示如果10个线程不够用了，就会自动增加到最多15个线程
第三个参数60 结合第四个参数TimeUnit.SECONDS，表示经过60秒，多出来的线程还没有接到活儿，就会回收，最后保持池子里就10个
第四个参数TimeUnit.SECONDS 如上
第五个参数 new LinkedBlockingQueue() 用来放任务的集合
execute方法用于添加新的任务