线程的创建

线程的创建

1.继承Thread + run(),对象.start()
2.实现Runnable + run 1.真实 2.代理 3. 代理.start() 代理持有真实角色
3.实现Callable + call 对象
	1. ExecutorService(Executors.newFixedThreadPool),
	2. Future(ExecutorService.submit（类对象)）
	3. 返回值类型 Future.get（），执行call()
	4. 停止服务 ExecutorService.shutdown（）

1.创建继承Thread类的线程类，重写run，通过线程类对象.start()来启动线程

class ExtendThread extends Thread{
	private Mediation mediation;
	public boolean flag = true;
	public ExtendThread(String name,Mediation mediation) {
		super(name);
		this.mediation = mediation;
	}
	@Override
	public void run() {
		while(flag) {
			if(mediation.num > 0) {
				try {
					go();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			else {
				break;
			}
		}	
	}
	
	public  synchronized void go() throws InterruptedException {
		String aString;
		if(mediation.num % 2 == 0) {
			aString = Thread.currentThread().getName() + " has num"+": "+mediation.num --;
			System.out.println(aString);
		}
	}
	
}

class Mediation{
	public int num = 500000;
}

主线程：
	Mediation mediation = new Mediation();
	ExtendThread myThread = new ExtendThread("Exended",mediation);
	myThread.start();
	Thread.sleep(1000);

//如上，共享资源并不方便，而且是单继承

2.创建实现Runnable类的实例对象，重写run方法，
再使用Thread proxy代理实例对象，并执行start()

class RunThread1 implements Runnable{
	private Mediation mediation;
	public boolean flag = true;
	public RunThread1 (Mediation mediation) {
		super();
		this.mediation = mediation;
	}
	@Override
	public void run() {
		while(flag) {
			if(mediation.num > 0) {
				try {
					go();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			else {
				break;
			}
		}
			
	}
	
	public  synchronized void go() throws InterruptedException {
		String aString;
		if(mediation.num % 2 == 0) {
			aString = Thread.currentThread().getName() + "has num"+": "+mediation.num --;
			System.out.println(aString);
		}
	}
}


主线程：
	Mediation mediation = new Mediation();
	RunThread1 myThread1 = new RunThread1(mediation);
	Thread proxy = new Thread(myThread1,"tiger");
	Thread proxy1 = new Thread(myThread1,"rabbit");
	proxy1.start();
	proxy.start();
	Thread.sleep(1000);
	myThread1.flag = false;

//如上，共享资源很方便	，无返回值，不可抛出异常

3.创建实现Callable接口的类，定义结果泛型，重写call方法

方法1：
1. 创建实现了Callable接口的类的对象，需要对类定义结果泛型，重写call方法
2. 通过Executors类创建线程池并赋值给ExecutorService类对象	
	ExecutorService eService = Executors.newCachedThreadPool();
3. 通过ExecutorService类对象，使用submit(),传入Callable对象作参数，
	并赋值给Future<泛型>类对象作异步计算
4.通过对Future类对象的get(),会执行call()并获取计算结果
5.对ExectorService类对象，执行shutdown，不再接受新的任务请求
	执行awaitTermination，阻止其他任务还继续执行
	再判断为false时，执行shutdownNow,停止主动执行的任务和等待的任务

方法2：
1. 创建实现了Callable接口的类的对象，需要对类定义结果泛型，重写call方法
2. 创建FutureTask<>泛型对象，传入callable类对象作参数
3. 创建Thread类对象，传入FutureTask<>泛型作参数
4. 通过Thread类对象，执行start()，会执行call()中，不包含返回值的其他代码
5. 通过对FutureTask对象.get()方法，才能处理call()返回值

共有第一步：创建实现Callable接口的类，定义结果泛型，重写call方法

	class CallThread implements Callable<Integer>{
	private Mediation mediation;
	public boolean flag = true;
	public CallThread(Mediation mediation) {
		this.mediation = mediation;
	}
	
	@Override
	public Integer call() throws Exception {
		while(flag) {
			if(mediation.num > 0) {
				try {
					go();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}	
			else {
				break;
			}
		}
		return Integer.valueOf(5);
	}
	
	public  synchronized void go() throws InterruptedException {
		String aString;
		if(mediation.num % 2 == 0) {
			aString = Thread.currentThread().getName()  + " has num"+": "+mediation.num--;
			System.out.println(aString);
		}
	}
	
	public void go1() throws InterruptedException {
		String aString;
		while(mediation.num > 0) {
			if(mediation.num % 2 == 0) {
				aString = Thread.currentThread().getName() + "has num"+": "+mediation.num --;
				System.out.println(aString);
			}
		}
	}
}

主线程：

方式1：

//1. 创建实现了Callable接口的类的对象，需要对类定义结果泛型，重写call方法
Mediation mediation = new Mediation();
CallThread callThread = new CallThread(mediation);

//2. 通过Executors类创建线程池并赋值给ExecutorService类对象	
ExecutorService eService = Executors.newCachedThreadPool();

//3. 通过ExecutorService类对象，使用submit(),传入Callable对象作参数，
	并赋值给Future<泛型>类对象作异步计算
Future<Integer> future  = eService.submit(callThread);
Future<Integer> future1  = eService.submit(callThread);

Thread.sleep(1000);
callThread.flag = false;

//4.通过对Future类对象的get(),会执行call()并获取计算结果
System.out.println(future.get(1000,TimeUnit.MILLISECONDS));
System.out.println(future1.get(1000,TimeUnit.MILLISECONDS));

//5.对ExectorService类对象，执行shutdown，不再接受新的任务请求
	执行awaitTermination，阻止其他任务还继续执行
	再判断为false时，执行shutdownNow,停止主动执行的任务和等待的任务
eService.shutdown();
if(!eService.awaitTermination(8*1000, TimeUnit.MILLISECONDS)){  
     eService.shutdownNow();  
 }  

方式2：

//1. 创建实现了Callable接口的类的对象，需要对类定义结果泛型，重写call方法
Mediation mediation = new Mediation();
CallThread callThread = new CallThread(mediation);

//2.创建FutureTask<>泛型对象，传入callable类对象作参数			
FutureTask<Integer> result  = new FutureTask<>(callThread);
FutureTask<Integer> result1  = new FutureTask<>(callThread);

//3. 创建Thread类对象，传入FutureTask<>泛型作参数
Thread thread = new Thread(result,"tiger");
Thread thread1 = new Thread(result1,"rabbit");

//4. 通过Thread类对象,执行start(),会执行call()中,不包含返回值的其他代码
thread.start();
thread1.start();	
Thread.sleep(1000);
callThread.flag = false;

//5. 通过对FutureTask对象.get()方法，才能处理call()返回值
System.out.println(result.get(1000,TimeUnit.MILLISECONDS));
System.out.println(result1.get(1000,TimeUnit.MILLISECONDS));

//如上，共享资源也很方便，有返回值，可抛出异常，且具备线程池，
	但不具备sleep,join,yield等