Java学习之多线程--创建线程的三种方式

一、Thread 创建线程
1、创建多线程  继承  Thread  +重写run(线程体)
2、使用线程: 创建子类对象 + 对象.start()  线程启动

class Rabbit extends Thread{
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println("兔子跑了"+i+"步");
		}		
	}
}


class Torties extends Thread{
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println("乌龟跑了"+i+"步");
		}		
	}
}

//1、创建多线程  继承  Thread  +重写run(线程体)
//2、使用线程: 创建子类对象 + 对象.start()  线程启动
public class TestThread {

	public static void main(String[] args) {
		Rabbit rab = new Rabbit();
		Torties tis= new Torties();
		
		rab.start();
		tis.start();
		
		for(int i=0;i<100;i++){
			System.out.println("main:"+i+"步");
		}		
	}
}

二、使用Runable 创建线程
1、类 实现Runnable接口+重写run() 
2、启动多线程  使用静态代理
1）、创建真实角色
2）、创建代理角色+真实角色引用
3）、调用.start 启动线程
注意：推荐 Runable创建线程
优点
1、避免单线程局限性
2、便于共享资源

class Run implements Runnable{

	@Override
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("run-->:"+i);
		}
	}	
}
public class TestRunnable {

	public static void main(String[] args) {
		Run run = new Run();
		Thread thread = new Thread(run);
		thread.start();
		
		for(int i=0;i<100;i++){
			System.out.println("TestRunnable-->:"+i);
		}
	}
}

静态代理模式：

1、真实角色
2、代理角色
3、二者实现相同的接口

public class StaticProxy {
	public static void main(String[] args) {
		//创建真实角色
		Action you =new You();
		//创建代理角色 +真实角色的引用
		Hotel company =new Hotel(you);
		//执行任务
		company.eat();
	}
}

//接口
interface Action{
	 void eat();
}
//真实角色
class You implements Action{

	@Override
	public void eat() {
		System.out.println("吃东西....");
	}
	
}
//代理角色
class Hotel implements Action{
	private Action you;
	public Hotel() {
	}
	
	public Hotel(Action you) {
		this.you = you;
	}
	private void before(){
		System.out.println("摆桌子");
		
	}
	private void after(){
		System.out.println("洗碗");
	}
	@Override
	public void eat() {
		before();
		you.eat();
		after();
	}
}

三、了解（服务器编程常用）
通过Callable接口实现多线程
优点：可以获取返回值
Callable和Future接口
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。
Callable和Runnable有几点不同：
（1）Callable规定的方法是call(),而Runnable规定的方法是run()
  (2)call()方法可以抛出异常，而run()方法是不能抛出异常的。
（3）Callable的任务执行后可返回值，运行Callable任务可拿到一个Future对象，而Runnable的任务是不能返回值得。Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，


并检索计算的结果.通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
缺点：繁琐
思路：
1、创建Callable实现类 + 重写call()
2、借助 执行调度服务 ExecutorService,获取Future对象
ExecutorService ser = Executors.newFixedThreadPool(2);
Future result = ser.submit(实现类对象)
3、获取值 result.get()
4、停止服务 ser.shutdownNow()