多线程

进程：一个正在运行的应用程序

线程：一个进程内部的多个运行单位，线程可以理解为程序内部一个独立的运行单位。

多线程模型：将代码的调用放到一个独立运行单元---即线程中，让多个调用并行执行。

代码示例：

public void ma(){
         在线程中调用mb();-------->
         在线程中调用mc();-------->
         在线程中调用md();-------->
         System.out.println("三个线程运行啦。。");
}
public void mb(){

}
public void mc(){

}
public void md(){

}

 在ma中对mb.mc,md的调用，会启动独立线程---这意味着ma的调用马上就会返回，而其中启动了三个线程，在这三个线程中并行运行mb,mc,md.

使用线程的两大优点：并行，省时。

 

多线程的实现：

1.每个线程对象都是继承了一个java.util.Thread类的对象或implements了java.util.Runnable接口的类的对象。

（1）继承Thread类实现线程

重写Thread类的run()方法，在run()方法中编写你的线程要实现的调用，然后创建该子类的实例，调用其start()方法启动线程。

public class CountFileThread extends Thread{
	public CountFileThread(String root){
		this.rootDirName=root;
	}
	//线程执行入口：调用线程对象的star()方法后，线程就从它的run方法开始独立执行
	public void run(){
		long start=System.currentTimeMillis();
		int fileCount=countDir(this.rootDirName);
		long timeCost=System.currentTimeMillis()-start;
		System.out.println("------驱动器："+this.rootDirName+"统计完毕"+"  ;共有文件数量："+fileCount+"  ;用时(单位：秒)："+timeCost/1000);
	}
	/**
	 * 计算一个目录下面所有文件的长度
	 * @param dir:要计算的目录的名字
	 * @return: 文件的总长度
	 */
	private int countDir(String dir){
		int count=0;//文件长度变量
		File dirFile=new File(dir);
		if(!dirFile.exists())//如果用户输入的目录不存在
		{
			return count;
		}
		File[] subFile=dirFile.listFiles();
		if(subFile==null)//如果列表子文件不存在
		{
			return count;
		}
		for(int i=0;i<subFile.length;i++){
			if(subFile[i].isDirectory()){
				//递归计算目录下文件长度
				count+=countDir(subFile[i].getAbsolutePath());
			}
			if(subFile[i].isFile()){
				count++;
			}
		}
		return count;
	}
	private String rootDirName;//本对象所操作的根目录的名称
}

 

public class MainCount extends Thread{
	public static void main(String[] args){
		//取得系统的根目录的个数
		java.io.File[] dirF=java.io.File.listRoots();
		//根据根目录个数创建统计线程对象并启动
		for(int i=0;i<dirF.length;i++){
			//创建线程对象
			CountFileThread cf=new CountFileThread(dirF[i].getAbsolutePath());
			cf.start();//启动线程
			
		}
		System.out.println(dirF.length+"个统计线程对象已启动...");
	}
}

 （2）实现Runnable接口创建线程

定义一个实现Runnable接口的类，实现它的run()方法，然后将这个类的实例作为Thread的构造方法的参数，创建Thread类的实例，既可作为线程的启动。（Thread类也是实现了Runnable接口的类）

public class RunnableTest implements Runnable{
	//程序启动主类
	public static void main(String args[]){
		for(int t=1000;t<1010;t++){
			RunnableTest rt=new RunnableTest(t);//创建Runnable对象
			Thread thread=new Thread(rt);//构造Thread对象
			thread.start();//启动线程
		}
	}
	//构造器传入这个线程的ID
	public RunnableTest(int id){
		this.id=id;
	}
	//线程运行入口
	@Override
	public void run() {
		// TODO Auto-generated method stub
		//循环输出当前时间点
		while(true){
			long currentTime=System.currentTimeMillis();
			System.out.println(id+"号线程："+currentTime);
		}
	}
	private int id;
}

 （3）以内部类的方式创建线程。既可以在一个方法中创建线程，当方法被调用时

 

2.线程的启运是通过调用线程对象的start()方法启动。

 

    3.线程运行是从线程对象的run方法开始，当线程对象的run()方法结束后，线程即运行结束。

 

Ps:其实个人简单理解就是 我们原来在写代码时，都是从主函数main()入口开始，按顺序一一执行直到函数结尾，而线程使得多个程序能同时进行。瞬间觉得高级了很多。再联系下我们写的小球练习，原来游戏中例如泡泡堂那些人物是可以用线程来写，这样它们就能同时行动了。