异步回调函数-创建进程的三种方式

Posted 2022-03-12 wind-man

回调函数

有两个类，A,B,在类A中调用B，在B中调用A的方法完成A的工作，那么这个在B类中调用的A的函数就称为回调函数。

异步回掉函数：类A将自己的工作交给类B后，继续执行剩下的程序，而B继续完成A交给的工作。

 

使用方法：

1、定义一个接口

2、A可以直接继承此接口，也可以定义一个内部类继承此接口；

　　定义一个方法，调用B中的方法

3、B中的方法调用A中的方法。

//定义接口
public interface doJob 
    public void fillBlank(int a,int b,int result) throws InterruptedException;


//定义A类
public class Student 
    private String name = null;

    public Student(String name)
        this.name = name;
    

    public void setName(String name) 
        this.name = name;
    

    public String getName() 
        return name;
    
    @SuppressWarnings("unused")
    private int calcAdd(int a,int b)
        return a+b;
    
    private int useCalculator(int a,int b)
        return new Calculator().add(a,b);
    
    public void fillBlank(int a,int b)
        int result = useCalculator(a,b);
        System.out.println(name + "使用计算器：" + a + " + " + b + " = " + result);
    
    public void fillBlank(int result)
        System.out.println(name + "使用计算器： a + b = " + result);
    
    public class doHomeWork implements doJob
        public void fillBlank(int a, int b, int result) throws InterruptedException 
            System.out.println(name + "求助小红计算：" +a+" + "+b+" = "+result);
        
    
    public void callHelp(final int a,final int b) throws InterruptedException 
        new Thread(new Runnable() 
            public void run() 
                try 
                    Thread.sleep(5000);
                    new SuperCalculator().add(a,b,new doHomeWork());
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            
        ).start();

    



//定义B类
public class SuperCalculator 
    public void add(int a,int b,doJob s) throws InterruptedException 
        int result = a +b;
        s.fillBlank(a,b,result);
    


//主函数，测试
public class Test 
    public static void main(String[] args) throws InterruptedException 
        int a =1;
        int b = 2;
        Student s = new Student("小明");
        s.callHelp(a,b);
        System.out.println("结束");
    

View Code

输出结果：
结束
小明求助小红计算：1 + 2 = 3

线程的三种方式

Runnable

实现Runnable接口，需要实现run方法，run方法中可以调用其他方法，使用其他类，并声明变量，就像主线程一样，代码如下：

public class RunableProcessor implements Runnable 
    private Thread t;
    private String threadName;

    public RunableProcessor(String threadName) 
        this.threadName = threadName;
    

    public void run() 
        System.out.println("ssss");
    
    public void start()
        t = new Thread(this,threadName);
        t.start();
    


//调用
public class TestThread 
 
   public static void main(String args[]) 
      RunnableProcessor R1 = new RunnableProcessor( "Thread-1");
      R1.start();
      

 

Thread

继承Thread类，run方法中可以调用其他方法，使用其他类，并声明变量，就像主线程一样，代码如下：

 

public class ThreadProcessor extends Thread 
    private String name = "sss";
    private Thread t;
    
    @Override
    public synchronized void start() 
        t = new Thread(this,name);
        t.start();
    

    @Override
    public void run() 
        System.out.println(name);
           

//调用
public class TestThread 
 
   public static void main(String args[]) 
      ThreadProcessorR1 = new ThreadProcessor( "Thread-1");
      R1.start();
      

Thread类本身有一些函数，比如修改进程名字，修改优先级。

Callable方式

此方式有返回值，需要继承Callable接口实现call方法。to那个锅FutureTask来完成调用。

 

//实现Callable接口
public class CallableProcessor implements Callable<String> 
    private String str = "s";
    public String call() throws Exception 
        String result = "";
        for(int i =0;i<20;i++)
            result.concat(str);
            result += str;
        
        return result;
    


//调用，并获取返回值
public class Test 
    public static void main(String[] args) 
        CallableProcessor callableProcessor = new CallableProcessor();
        FutureTask<String> ft = new FutureTask<String>(callableProcessor);
        Thread t = new Thread(ft);
        t.start();
        try 
            System.out.println(ft.get());
         catch (InterruptedException e) 
            e.printStackTrace();
         catch (ExecutionException e) 
            e.printStackTrace();
        
        System.exit(0);