我理解的通信就是数据信息之间的互相传递.那么Thread之间的通信也无法跳出这个定义.
在Thread之间通信只要采用回调的方式.
那么什么是回调了?举个简单的例子:A把作业写完后告诉B.其实B有很多种方式可以获得A的状态.1.定时检测A,查看A的状态.但是会造成资源的浪费.也就是B要是不是的停下来询问A是否完成作业.2.让A在适当的时候主动的将状态回传给B.方式2就采用了回调机制.
1.静态回调
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Teacher {
public static void getStudentStatus(String status){
//you can do something here
System.out.println(status);
//you can do something here
}
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new Thread(new StudentThread(true)));
service.execute(new Thread(new StudentThread(false)));
service.shutdown();
}
}
public class StudentThread implements Runnable {
private boolean isPlay;
public StudentThread(boolean isPlay) {
this.isPlay = isPlay;
}
@Override
public void run() {
if(isPlay) {
//you can do something here
Teacher.getStudentStatus("rest");
} else {
//you can do something here
Teacher.getStudentStatus("inclass");
}
}
}
优点:不用实例化对象可以直接应用,如果是变量可以直接赋值
缺点:
1.在初始化时被加载,如果后续不被使用增加内存的负荷影响效率(一般很小).如果是变量多处使用的话导致数据混乱.增加维护成本.
2.无法享受面向对象带来的特性
2.实例回调
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Teacher {
private String type;
public Teacher(String type) {
this.type = type;
}
public void getStudentStatus(String status){
//you can do something here
System.out.println("student status:" + status + " , teacher type " + type);
//you can do something here
}
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new Thread(new StudentThread(true, new Teacher("Sports"))));
service.execute(new Thread(new StudentThread(false, new Teacher("math"))));
service.shutdown();
}
}
public class StudentThread implements Runnable {
private boolean isPlay;
private Teacher teacher;
public StudentThread(boolean isPlay,Teacher teacher) {
this.isPlay = isPlay;
this.teacher = teacher;
}
@Override
public void run() {
if(isPlay) {
//you can do something here
teacher.getStudentStatus("rest");
} else {
//you can do something here
teacher.getStudentStatus("inclass");
}
}
}
//output:
student status:inclass , teacher type math
student status:rest , teacher type Sports
优点:
1.可以在其他线程触发该实例的相关动作.也就是可以操作该实例
缺点:
1.其他线程持有特定的对象,不方便后续的扩展
3.接口回调
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Teacher implements Callback{
private String type;
public Teacher(String type) {
this.type = type;
}
@Override
public void callback(String status) {
//you can do something here
System.out.println("student status:" + status + " , teacher type " + type);
//you can do something here
}
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new Thread(new StudentThread(true, new Teacher("Sports"))));
service.execute(new Thread(new StudentThread(false, new Teacher("math"))));
service.shutdown();
}
}
public class StudentThread implements Runnable {
private boolean isPlay;
private Callback teacherCallback;
public StudentThread(boolean isPlay,Callback teacherCallback) {
this.isPlay = isPlay;
this.teacherCallback = teacherCallback;
}
@Override
public void run() {
if(isPlay) {
//you can do something here
teacherCallback.callback("rest");
} else {
//you can do something here
teacherCallback.callback("inclass");
}
}
}
public interface Callback {
public void callback(String status);
}
//output
student status:rest , teacher type Sports
student status:inclass , teacher type math
优点:
1.可以在其他线程触发该实例的相关动作.也就是可以操作该实例
2.其他线程持有的是接口对象,那么凡是接受该接口参数的线程都可处理该接口的实现
缺点:NA
接口回调是能够发挥面向对象特性最大优势的回调方式
4.实现Callable接口
package callable;
import java.util.concurrent.Callable;
public class StudentThread implements Callable<String> {
private boolean isPlay;
public StudentThread(boolean isPlay) {
this.isPlay = isPlay;
}
@Override
public String call() throws Exception {
if(isPlay) {
//you can do something here
return "rest";
} else {
//you can do something here
return "inclass";
}
}
}
package callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Teacher {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
Future<String> future = service.submit(new StudentThread(true));
try {
System.out.println("stutent status: " + future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}finally {
service.shutdown();
}
}
}
//output
stutent status: rest
这种方式的优缺点暂时还不知道.后续研究后在更新
有关各种回调的优缺点希望大家继续补充.谢谢!