理解Runnable和Thread的区别：https://blog.csdn.net/zhaojianting/article/details/9766437
多线程即在同一时间，可以做多件事情。
创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类
-
启动一个线程
线程有三种创建方法：
1.继承Thread类的方式
public class Testthread extends Thread{
public void run(){
//
}
}
run方法里面就是写你这个线程要做的事情。
然后：
TestThread t1=new TestThread();
t1.start();
通过.start()方法就可以开始t1这个线程啦！
2.实现Runnable的方式
public class ttt implements Runnable{
public void run(){
}
}
然后：
ttt t2 = new ttt();
new Thread(t2).start();
就可以开始t2这个线程啦，需要注意的同样也是要有.start(）才能运行这个线程。
3.匿名类的方式
这也是我喜欢的方式，因为写起来方便
Thread t3 = new Thread() {
public void run()
{
//
}
};
同样的要注意：启动线程是start()方法，run()并不能启动一个新的线程。
1 package UML; 2 /* 3 *多线程即在同一时间，可以做多件事情。 4 *创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类 5 *线程的概念：首先要理解进程(Processor)和线程(Thread)的区别 6 进程：启动一个LOL.exe就叫一个进程。 接着又启动一个DOTA.exe，这叫两个进程。 7 线程：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如"盖伦” 击杀“提莫”，同时“赏金猎人”又在击杀“盲僧”，这就是由多线程来实现的。 8 */ 9 public class TestThread { 10 11 public static void main(String[] args) { 12 13 Hero gareen = new Hero(); 14 gareen.name = "盖伦"; 15 gareen.hp = 616; 16 gareen.damage = 50; 17 18 Hero teemo = new Hero(); 19 teemo.name = "提莫"; 20 teemo.hp = 300; 21 teemo.damage = 30; 22 23 Hero bh = new Hero(); 24 bh.name = "赏金猎人"; 25 bh.hp = 500; 26 bh.damage = 65; 27 28 Hero leesin = new Hero(); 29 leesin.name = "盲僧"; 30 leesin.hp = 455; 31 leesin.damage = 80; 32 33 //方法1 创建多线程-继承线程类 34 /*使用多线程，就可以做到盖伦在攻击提莫的同时，赏金猎人也在攻击盲僧设计一个类KillThread 继承Thread，并且重写run方法启动线程办法： 实例化一个KillThread对象，并且调用其start方法就可以观察到 赏金猎人攻击盲僧的同时，盖伦也在攻击提莫 35 KillThread killThread1=new KillThread(gareen,teemo); 36 killThread1.start(); 37 KillThread killThread2 = new KillThread(bh,leesin); 38 killThread2.start();*/ 39 40 //方法2 创建多线程-实现Runnable接口 41 /*创建类Battle，实现Runnable接口。启动的时候，首先创建一个Battle对象，然后再根据该battle对象创建一个线程对象，并启动 42 Battle b1=new Battle(gareen,teemo);//b1 对象实现了Runnable接口，所以有run方法，但是直接调用run方法，并不会启动一个新的线程。 43 new Thread(b1).start();//必须借助一个线程对象的start()方法，才会启动一个新的线程，这个线程启动的时候，就会去执行b1.run()方法 44 Battle b2=new Battle(bh,leesin); 45 new Thread(b2).start();*/ 46 47 /*方法3 创建多线程-匿名类 48 * 使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码 49 * 匿名类的一个好处是可以很方便的访问外部的局部变量。 50 * 前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了) */ 51 Thread t1=new Thread() { 52 public void run() { 53 while(!teemo.isDead()) { 54 gareen.attackHero(teemo); 55 } 56 } 57 }; 58 t1.start(); 59 60 Thread t2=new Thread() { 61 public void run() { 62 while(!teemo.isDead()) { 63 bh.attackHero(leesin); 64 } 65 } 66 }; 67 t2.start(); 68 } 69 }
1 package UML; 2 3 public class KillThread extends Thread { 4 private Hero h1; 5 private Hero h2; 6 7 public KillThread(Hero h1, Hero h2){ 8 this.h1 = h1; 9 this.h2 = h2; 10 } 11 12 public void run(){ 13 while(!h2.isDead()){ 14 h1.attackHero(h2); 15 } 16 } 17 }
1 package UML; 2 3 public class Battle implements Runnable { 4 5 private Hero h1; 6 private Hero h2; 7 public Battle(Hero h1,Hero h2) { 8 this.h1=h1; 9 this.h2=h2; 10 } 11 @Override 12 public void run() { 13 // TODO Auto-generated method stub 14 while(!h2.isDead()) { 15 h1.attackHero(h2); 16 } 17 18 } 19 20 }
1 package UML; 2 import java.util.*; 3 public class Hero implements Comparable<Hero>{ 4 public String name; 5 public float hp; 6 public int damage; 7 public Hero() { 8 } 9 // 增加一个初始化name的构造方法 10 public Hero(String name) { 11 12 this.name = name; 13 } 14 // 重写toString方法 15 public String toString() { 16 //return String.format("[name:%s hp:%.0f damage:%.0f]%n", name,hp,damage); 17 return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "] "; 18 } 19 public Hero(String name,int hp,int damage) { 20 this.name=name; 21 this.hp=hp; 22 this.damage=damage; 23 } 24 @Override 25 public int compareTo(Hero anotherHero) { 26 if(damage<anotherHero.damage) 27 return 1; 28 else 29 return -1; 30 } 31 public void attackHero(Hero h) { 32 try { 33 Thread.sleep(1000); 34 }catch (InterruptedException e) { 35 // TODO Auto-generated catch block 36 e.printStackTrace(); 37 } 38 h.hp-=damage; 39 System.out.format("%s is attacking %s,%s'blood now is %.0f%n",name,h.name,h.name,h.hp); 40 if(h.isDead()) 41 System.out.println(h.name +"死了！"); 42 } 43 public boolean isDead() { 44 return 0>=hp?true:false; 45 } 46 }
-
线程常用方法
1、暂停当前线程： .sleep()
顾名思义，把当前的线程暂停一定时间，其他的线程并不会受到影响。
注意是会抛出interruptedException异常的。
2、加入到当前线程中： .join()
join的作用是当这个线程运行完事儿之后程序才继续往下走，不然会一直停在join方法处。
使用场景：如果在某处后边的处理需要使用到t1的数据，那么可以用join来等待t1线程执行结束。
3、定义线程的优先级： .setPriority()
当线程处于竞争关系的时候，优先级高的线程会获得更多的cup资源，也就是这个线程会执行得更快
4、临时暂停： .yield
并不是直接就给它停住了，而是它自己也在慢慢运行，但是会把更多的cup资源让给其他的线程。
5、守护线程： .setDaemon(true)
守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。
就是说可以用来把一些辅助线程写成守护的，那么当干实事的线程完事了，这些守护的线程就没必要继续了。
比如写日志啊，性能统计等。
1 package UML; 2 3 import java.util.*; 4 5 public class TestThread1 { 6 /*当前线程暂停 7 Thread.sleep(1000); 表示当前线程暂停1000毫秒 ，其他线程不受影响 8 Thread.sleep(1000); 会抛出InterruptedException 中断异常，因为当前线程sleep的时候， 9 有可能被停止，这时就会抛出 InterruptedException */ 10 public static void example1() { 11 Thread t1=new Thread() { 12 public void run() { 13 int seconds=0; 14 while(true) { 15 try { 16 Thread.sleep(1000); 17 }catch(InterruptedException e) { 18 e.printStackTrace(); 19 } 20 System.out.printf("已经玩了LOL %d 秒%n", seconds++); 21 } 22 } 23 }; 24 t1.start(); 25 } 26 27 /*所有进程，至少会有一个线程即主线程，即main方法开始执行，就会有一个看不见的主线程存在。 28 在42行执行t.join，即表明在主线程中加入该线程。 29 主线程会等待该线程结束完毕， 才会往下运行。 */ 30 public static void example2() { 31 final Hero gareen = new Hero(); 32 gareen.name = "盖伦"; 33 gareen.hp = 616; 34 gareen.damage = 50; 35 36 final Hero teemo = new Hero(); 37 teemo.name = "提莫"; 38 teemo.hp = 300; 39 teemo.damage = 30; 40 41 final Hero bh = new Hero(); 42 bh.name = "赏金猎人"; 43 bh.hp = 500; 44 bh.damage = 65; 45 46 final Hero leesin = new Hero(); 47 leesin.name = "盲僧"; 48 leesin.hp = 455; 49 leesin.damage = 80; 50 51 Thread t1= new Thread(){ 52 public void run(){ 53 while(!teemo.isDead()){ 54 gareen.attackHero(teemo); 55 } 56 } 57 }; 58 59 t1.start(); 60 //代码执行到这里，一直是main线程在运行 61 try { 62 //t1线程加入到main线程中来，只有t1线程运行结束，才会继续往下走 63 t1.join(); 64 } catch (InterruptedException e) { 65 // TODO Auto-generated catch block 66 e.printStackTrace(); 67 } 68 69 Thread t2= new Thread(){ 70 public void run(){ 71 while(!leesin.isDead()){ 72 bh.attackHero(leesin); 73 } 74 } 75 }; 76 //会观察到盖伦把提莫杀掉后，才运行t2线程 77 t2.start(); 78 } 79 80 /* 线程优先级 81 * 当线程处于竞争关系的时候，优先级高的线程会有更大的几率获得CPU资源 82 为了演示该效果，要把暂停时间去掉，多条线程各自会尽力去占有CPU资源 83 同时把英雄的血量增加100倍，攻击减低到1，才有足够的时间观察到优先级的演示 84 如图可见，线程1的优先级是MAX_PRIORITY，所以它争取到了更多的CPU资源执行代码 85 */ 86 public static void example3() { 87 final Hero gareen = new Hero(); 88 gareen.name = "盖伦"; 89 gareen.hp = 6160; 90 gareen.damage = 1; 91 92 final Hero teemo = new Hero(); 93 teemo.name = "提莫"; 94 teemo.hp = 3000; 95 teemo.damage = 1; 96 97 final Hero bh = new Hero(); 98 bh.name = "赏金猎人"; 99 bh.hp = 5000; 100 bh.damage = 1; 101 102 final Hero leesin = new Hero(); 103 leesin.name = "盲僧"; 104 leesin.hp = 4505; 105 leesin.damage = 1; 106 107 Thread t1= new Thread(){ 108 public void run(){ 109 110 while(!teemo.isDead()){ 111 gareen.attackHero(teemo); 112 } 113 } 114 }; 115 116 Thread t2= new Thread(){ 117 public void run(){ 118 while(!leesin.isDead()){ 119 bh.attackHero(leesin); 120 } 121 } 122 }; 123 124 t1.setPriority(Thread.MAX_PRIORITY); 125 t2.setPriority(Thread.MIN_PRIORITY); 126 t1.start(); 127 t2.start(); 128 } 129 /*临时暂停 130 * 当前线程，临时暂停，使得其他线程可以有更多的机会占用CPU资源 131 */ 132 public static void example4() { 133 final Hero gareen = new Hero(); 134 gareen.name = "盖伦"; 135 gareen.hp = 61600; 136 gareen.damage = 1; 137 138 final Hero teemo = new Hero(); 139 teemo.name = "提莫"; 140 teemo.hp = 30000; 141 teemo.damage = 1; 142 143 final Hero bh = new Hero(); 144 bh.name = "赏金猎人"; 145 bh.hp = 50000; 146 bh.damage = 1; 147 148 final Hero leesin = new Hero(); 149 leesin.name = "盲僧"; 150 leesin.hp = 45050; 151 leesin.damage = 1; 152 153 Thread t1= new Thread(){ 154 public void run(){ 155 156 while(!teemo.isDead()){ 157 gareen.attackHero(teemo); 158 } 159 } 160 }; 161 162 Thread t2= new Thread(){ 163 public void run(){ 164 while(!leesin.isDead()){ 165 //临时暂停，使得t1可以占用CPU资源 166 Thread.yield(); 167 168 bh.attackHero(leesin); 169 } 170 } 171 }; 172 173 t1.setPriority(5); 174 t2.setPriority(5); 175 t1.start(); 176 t2.start(); 177 } 178 /* 守护线程 179 * 守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。 180 就好像一个公司有销售部，生产部这些和业务挂钩的部门。 181 除此之外，还有后勤，行政等这些支持部门。 182 如果一家公司销售部，生产部都解散了，那么只剩下后勤和行政，那么这家公司也可以解散了。 183 守护线程就相当于那些支持部门，如果一个进程只剩下守护线程，那么进程就会自动结束。 184 守护线程通常会被用来做日志，性能统计等工作。 185 */ 186 public static void example5() { 187 Thread t1= new Thread(){ 188 public void run(){ 189 int seconds =0; 190 191 while(true){ 192 try { 193 Thread.sleep(1000); 194 } catch (InterruptedException e) { 195 // TODO Auto-generated catch block 196 e.printStackTrace(); 197 } 198 System.out.printf("已经玩了LOL %d 秒%n", seconds++); 199 200 } 201 } 202 }; 203 t1.setDaemon(true); 204 t1.start(); 205 } 206 /* 练习-英雄充能 207 * 英雄有可以放一个技能叫做: 波动拳-a du gen。 208 每隔一秒钟，可以发一次，但是只能连续发3次。 209 发完3次之后，需要充能5秒钟，充满，再继续发。 210 借助本章节学习到的知识点，实现这个效果 211 */ 212 public static void example6() { 213 Thread t1 = new Thread() { 214 public void run() { 215 216 for(int i = 0;i < 5;i ++) 217 { 218 for(int j = 0;j < 3;j ++) { 219 System.out.println("正在发送第"+(j+1)+"波动拳"); 220 try { 221 Thread.sleep(1000); 222 }catch(InterruptedException e ) { 223 e.printStackTrace(); 224 } 225 } 226 System.out.println("开始为时5s的充能"); 227 try { 228 Thread.sleep(5000); 229 }catch(InterruptedException e ) { 230 e.printStackTrace(); 231 } 232 } 233 } 234 235 }; 236 t1.start(); 237 } 238 /*练习-破解密码 239 * 1. 生成一个长度是3的随机字符串，把这个字符串当作 密码 240 2. 创建一个破解线程，使用穷举法，匹配这个密码 241 3. 创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程 242 提示： 破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。 如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。 243 244 */ 245 public static void example7() { 246 //提示：破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。 如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。 247 List<String> passwords = new ArrayList<String>();//容器记录产生的可能密码 248 //1.生成随机字符串pwd 249 String s="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 250 char cs[]=new char[3]; 251 for(int i=0;i<cs.length;i++) { 252 int index=(int)(Math.random()*s.length()); 253 cs[i]=s.charAt(index); 254 } 255 String pwd = new String(cs); 256 System.out.println("设置的密码为："+pwd); 257 //2.创建一个破解线程，使用穷举法，匹配这个密码 258 Thread t1 = new Thread() { 259 public void run() { 260 for(char i='0';i<='z';i++) { 261 if(Character.isDigit(i)||Character.isAlphabetic(i)) { 262 for(char j='0';j<='z';j++) { 263 if(Character.isDigit(j)||Character.isAlphabetic(j)) { 264 for(char k='0';k<='z';k++) { 265 if(Character.isDigit(k)||Character.isAlphabetic(k)) { 266 StringBuffer buf=new StringBuffer(); 267 buf.append(i); 268 buf.append(j); 269 buf.append(k); 270 passwords.add(buf.toString()); 271 System.out.println("产生的新密码是："+buf.toString()); 272 if(buf.toString().equals(pwd)) { 273 System.out.println("找到了，密码是" + buf+"即将退出破解线程"); 274 return; 275 }else { 276 System.out.println("..."); 277 } 278 } 279 } 280 } 281 } 282 } 283 } 284 } 285 }; 286 t1.start(); 287 //3.创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程 288 Thread t2= new Thread() { 289 public void run() { 290 while(true) { 291 if(passwords.isEmpty()) { 292 try { 293 Thread.sleep(1000); 294 }catch(InterruptedException e) { 295 e.printStackTrace(); 296 } 297 } 298 System.out.println("最新穷举的密码："+passwords.get(passwords.size()-1)); 299 } 300 301 } 302 }; 303 t2.setDaemon(true); 304 t2.start(); 305 } 306 public static void main(String[] args) { 307 //example1();//当前线程暂停 308 //example2();//在主线程中加入线程 309 //example3();//线程优先级 310 //example4();//临时暂停 311 //example5();//守护进程 312 313 314 //example6();//作业1-波动拳 315 example7();//作业2-破解密码 316 317 } 318 }