JAVA—事务处理三种方式：Thread，Runnable，Callable

JAVA—事务处理三种方式：

1.Thread
说明：Thread 类中包含run方法，通过改写run方法，然后实例化Thread 类，执行事务。
代码实现

public class Threadnew {
    public static void main(String[] args) {
        //1.2匿名实例化类继承MyThread类，并且启动
        new MyThread().start();       
        }
}
//1.1自定义继承MyThread类继承Thread类，改写run方法
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread");
    }
}

2.Runnable
说明：
Runnable接口中含有run方法，通过创建其他类继承该接口，重写该方法，在main 实例化 重写类，然后调用Thread调用实例化重写类，执行事务。
代码实现：

import java.util.concurrent.Callable;
public class Threadnew {
    public static void main(String[] args) {
        //2.2调用Thread调用实例化重写类，执行穿件子线程任务
        new Thread( new MyThread2()).start();
    }
}
//2.1通过创建类继承Runnnable 接口，改写run方法
class MyThread2 implements Runnable{

    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

3. Callable
说明：**
通过FutureTask类 接受改写Callable 的call方法的实例类，将接受接受改写Callable 的call方法 的FutureTask类传入Thread类中并且执行事务。通过源码我们可以发现 Callable的call方法被 Runnable 接口调用，接受接受改写Callable 的call方法的FutureTask类，相当于Runnable接口，最后通过Thread方法来执行事务。

代码实现：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Threadnew {
    public static void main(String[] args) {
        //3.将继承Callable的类实例化，传入FutureTask类，实例化futureTask，将实例化的futureTask的传入Thread类中，执行子线程
        FutureTask<Integer> futureTask=new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer=futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//3.1实例化类继承 接口Callable，改写call方法
class MyThread3 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        return 100;
    }
}