多线程创建的三种方式

╰半夏微凉° 2022-04-24 15:00 265阅读 0赞

### 多线程创建的三种方式 ###

*   *  1. 继承线程类
     *  2. 实现Runnable接口
     *  3. 匿名类
     *  4. 练习题，多线程遍历文件找指定内容
     *  进程和线程的区别
     *  其余的代码

创建多线程有3种方式，分别是  
**继承线程类,实现Runnable接口,匿名类**

以下通过how2j上部分代码和文字作为理解  
文章原始链接如下：[http://how2j.cn/p/1581][http_how2j.cn_p_1581]

**代码实现场景：**  
盖伦杀掉提莫，赏金猎人杀盲僧，**同时进行**

--------------------

## 1. 继承线程类 ##

**实现方法：**

1.  KillThread 继承Thread，重写run方法
2.  实例化一个KillThread对象，并且调用其start方法

**具体代码如下：**

**KillThread.java**

package DuoXianCheng;
    
    
    //设计一个类KillThread 继承Thread，并且重写run方法 
    //启动线程办法： 实例化一个KillThread对象，并且调用其start方法 
    
    public class KillThread extends Thread{ 
    
    	
    	private Hero h1;
    	private Hero h2;
    	
    	
    	public KillThread(Hero h1, Hero h2) { 
    		this.h1 = h1;
    		this.h2 = h2;
    	}
    	
    	public void run() { 
    		while(!h2.isDead()) { 
    			h1.attckHero(h2);
    		}
    	}
    	
    }

**TeatThread.java**

package DuoXianCheng;
    
    public class TeatThread { 
    
    	
    	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;
    		
            //1.继承线程类
            //实例化一个KillThread对象，并且调用其start方法 
            KillThread killThread1 = new KillThread(garen, teemo);
            killThread1.start();
            
            KillThread killThread2 = new KillThread(bh, leesin);
            killThread2.start();
            
          
    	}
    }

## 2. 实现Runnable接口 ##

**实现方法：**

1.  创建类Battle，实现Runnable接口
2.  创建一个Battle对象，然后再根据该battle对象创建一个线程对象，并启动

**具体代码如下：**

**Battle.java**

package DuoXianCheng;
    
    
    //创建多线程-实现Runnable接口
    
    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.attckHero(h2);
    		}
    	}
    }

**TeatThread.java**

package DuoXianCheng;
    
    public class TeatThread { 
    
    	
    	
    	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;
    		
    
            
            //2.实现Runnable接口
            //创建类Battle，实现Runnable接口
            //启动的时候，首先创建一个Battle对象，然后再根据该battle对象创建一个线程对象，并启动
            Battle battle1 = new Battle(garen, teemo);
            new Thread(battle1).start();
            
            Battle battle2 = new Battle(bh, leesin);
            new Thread(battle2).start();
            
    	}
    }

## 3. 匿名类 ##

使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码  
匿名类的一个好处是可以很方便的访问外部的局部变量。  
前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了)

**TeatThread.java**

package DuoXianCheng;
    
    public class TeatThread { 
    
    	
    
    	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;
    		
    
            //3.匿名类
            //使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码
            
            Thread t1 = new Thread() { 
            	
            	public void run() { 
            		while(!teemo.isDead()) { 
            			garen.attckHero(teemo);
            		}
            	}
            };
            
            t1.start();
            
            Thread t2 = new Thread() { 
            	
            	public void run() { 
            		while(!leesin.isDead()) { 
            			bh.attckHero(leesin);
            		}
            	}
            };
            
            t2.start();
    	}
    }

## 4. 练习题，多线程遍历文件找指定内容 ##

**题目：**

把普通查找文件内容改为**多线程**查找文件内容  
原练习的思路是遍历所有文件，当遍历到文件是 .txt的时候，查找这个文件的内容，查找完毕之后，再遍历下一个文件

现在通过多线程调整这个思路：  
遍历所有文件，当遍历到文件是.txt的时候，创建一个线程去查找这个文件的内容，不必等待这个线程结束，继续遍历下一个文件

**思路：**  
用遍历文件，查找到文件后缀相同的时候创建一个线程匿名类，接下来用迭代达到查找文件内容的目的

**本代码实现的内容：**  
寻找的是D:/LOL中包含1这个字段的的文本

**代码如下：**

package DuoXianCheng;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class ChaZhaoWenJianNeiRong { 
    
    	/* 把 练习-查找文件内容 改为多线程查找文件内容 原练习的思路是遍历所有文件，当遍历到文件是 .txt的时候，查找这个文件的内容，查找完毕之后，再遍历下一个文件 现在通过多线程调整这个思路： 遍历所有文件，当遍历到文件是.java的时候，创建一个线程去查找这个文件的内容，不必等待这个线程结束，继续遍历下一个文件 */
    	
    	public static void main(String[] args) { 
    		
    		File f = new File("D:/LOL");
    		if(!f.exists()) { 
    			System.out.println(f.getAbsolutePath() + "不存在");
    			return;
    		}
    		search(f, "1");
    		
    	}
    	
    	
    	public static void search(File f, String str) { 
    		
    		File[] filelist = f.listFiles();
    		
    		if(null != filelist) { 
    			for (File f1 : filelist) { 
    				if (f1.isDirectory()) { 
    					search(f1, str);
    				} else { 
    					if(f1.getName().endsWith(".txt")) { 
    						
    						//匿名类
    						Thread t = new Thread() { 
    							public void run(){ 
    								
    								try (
    										FileReader fis  = new FileReader(f1);
    										BufferedReader br = new BufferedReader(fis);
    										
    										){ 
    									
    									
    									while(true) { 
    										String s = br.readLine();
    										if(null == s) { 
    											break;
    										} else if(str.contains(str)) { 
    											System.out.println(f1.getAbsolutePath() + "有" + str);
    											break;
    										}
    									}
    								} catch(IOException e) { 
    									e.printStackTrace();
    								}
    							}
    						};
    						
    						
    						t.start();
    					} else { 
    						search(f1, str);
    					}
    				}
    			}
    		}
    	}
    	
    }

## 进程和线程的区别 ##

**进程：** 启动一个LOL.exe就叫一个进程。 接着又启动一个DOTA.exe，这叫两个进程。

**线程：** 线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如"盖伦” 击杀“提莫”，同时“赏金猎人”又在击杀“盲僧”，这就是由多线程来实现的。

## 其余的代码 ##

**如果要运行，请包含以下代码：**

**Hero.java**

package DuoXianCheng;
    
    public class Hero { 
    
    	 public String name;
    	 public float hp;
    	 public int damage;
    	 
    	 public boolean isDead() { 
    		 return hp <= 0 ? true : false;
    	 }
    	 
    	 public void attckHero(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 + " go Dead！");
    		 }
    	 }
    }

[http_how2j.cn_p_1581]: http://how2j.cn/p/1581