线程的创建

线程的创建

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等
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值