多线程（过年有多开心，开学就有多惨）

#今日小故事
开学第一次考试了，而我最讨厌的就是考试，一听到考试这两个字头就疼，放个假回来，前面的知识点又还给老师一部分了（我也很不想还的，毕竟吃亏的是我啊）。。。
原本以为在我读书阶段的最后一个寒假中我会很开心，过一个有趣的假期，结果没想到，在大年初一我进了医院！！！这可真是太棒了，让我简直从未想象过会有这么一天，当然生病后的我更没心思学习，整日与床为伴，简直不要太幸福。当然幸福的日子总是那么短暂，这次的考试超级也是那么的惨淡。。。。。。。。。
罢了罢了，还是开始今天的内容。

进程与线程：

进程（Process）
通俗来讲就是电脑使用时运行中的任务
特点：
1、 独立性：系统进行资源分配和调用的独立单位
2、 动态性：进程是处于运行过程中的程序
3、 并发性：多个进程可以在单处理器上并发执行，多个进程之间不会相互影响（例如：边写代码边听音乐）
线程：也称轻量级进程
每个进程中可以有一个或者多个线程，线程才是程序中真正的执行体
线程的执行是抢占式的。
线程间的运行是随机的

线程的创建与启动：

Runnable接口用于定义线程的执行体，只有run一个方法。
Thread实现了Runnable接口，但它的run方法没有实现任何东西，需要在Thread子类中实现进程执行体。

创建线程的常用方法：

（1）继承Thread并重写run()方法
使用Thread创建线程
步骤：a.定义子类继承自Thread并重写run()
b.创建子类实例
c.通过start()方法启动线程

package com.etime02;
public class MyThread1 extends Thread {
	//构造函数	
	public MyThread1(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
		public MyThread1() {
		super();
		// TODO Auto-generated constructor stub
	}
	//重写run方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		//子线程干的事情放在run方法里
		for (int i = 0; i < 100; i++) {
			System.out.println("子线程1在打印i="+i);
		}
		}
}

package com.etime02;

public class MyThread2 extends Thread {
	//构造函数
	public MyThread2(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	
	public MyThread2() {
		super();
		// TODO Auto-generated constructor stub
	}
	//重写run方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		for (int i = 0; i < 100; i++) {
			System.out.println("子线程2在打印i="+i);
		}
		
	}

}

package com.etime02;
public class Test1 {
	public static void main(String[] args) {
		MyThread1 thread1 = new MyThread1("thread1");//创建子线程
		thread1.start();//启动子线程
		String name1 = thread1.getName();//获取子线程名字
		System.out.println("获取子线程名字:"+name1);
		String name2 = Thread.currentThread().getName();//获取当前线程的名称
		System.out.println("获取当前线程的名称:"+name2);
		}
}

package com.etime02;

public class Test2 {

	public static void main(String[] args) {
		MyThread1 thread1 = new MyThread1("thread1");//创建子线程1
		thread1.start();//启动子线程
		
		MyThread2 thread2 = new MyThread2("thread2");//创建子线程2
		thread2.start();//启动子线程
	
	}

}

（2）实现Runnable接口
使用Runnable创建线程
步骤：a.定义Runnable接口的实现类，并重新run()方法
b.创建Runnable实现类的对象
c.创建Thread类的对象
d.通过start()方法启动线程

package com.etime03;
public class RunnableImpl1 implements Runnable{
	@Override
	public void run() {
		String name =Thread.currentThread().getName();
		for (int i = 0; i < 100; i++) {
			System.out.println(name+",i="+i);
		}	
	}
}

package com.etime03;
public class Test1 {
	public static void main(String[] args) {
		RunnableImpl1 runnableImpl1 = new RunnableImpl1();
		Thread thread1 = new Thread(runnableImpl1);
		thread1.start();
		RunnableImpl1 runnableImpl2 = new RunnableImpl1();
		Thread thread2 = new Thread(runnableImpl2);
		thread2.start();
	}
}

（3）利用Callable接口
使用Callable创建线程
步骤：a.定义Callable接口的实现类，并重新run()方法
b.创建Callable实现类的对象
c.创建FutureTask实现类的对象(FutureTask实现Runnable接口)
d.创建Thread类的对象
e.通过start()方法启动线程

package com.etime04;
import java.util.concurrent.Callable;

public class CallableImpl1 implements Callable<Object>{

	@Override
	public Object call() throws Exception {
		String name = Thread.currentThread().getName();
		for (int i = 0; i < 100; i++) {
			System.out.println(name+",i="+i);
		}
		return "线程进行完成";//自动封装将String封装为包装类String
	}
}

package com.etime04;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test1 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CallableImpl1 callableImpl1 = new CallableImpl1();
		FutureTask<Object> futureTask = new FutureTask<>(callableImpl1);//将要进行测试的线程
		Thread thread = new Thread(futureTask);//多态；FutureTask实现了Runnable接口
		thread.start();
		
		//获取第一个子线程的返回结果
		Object object = futureTask.get();
		System.out.println(object);
	}
}

总结呀重点呀：

• Thread类的run()方法是一个空方法体，需要在子类中重写run()方法实现处理逻辑
• 如果直接调用线程对象的run()方法，JVM不会作为一个新线程来运行，只是普通方法调用
• Thread.start()启动新线程
• 在子线程内部使用Thread.currentThread().getName()获取线程名
• 通过线程对象的getName()方法获取线程名
• 在同一个进程中不同线程随机执行