线程的创建
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等