java多线程的创建方式

线程的创建方式

通过继承Thread类来创建线程

//分别创建两个类分别继承Thread创建线程
public class ThreadA extends Thread {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
        //打出当前线程的名字
       System.out.println("a"+this.getName()+"......"+i);
       try{
           Thread.sleep(1000);//执行完一次后睡眠一秒
       }catch(Exception e){
       }
        }
    }
}

public class ThreadB extends Thread {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println("b"+this.getName()+"......"+i);
           try{
               Thread.sleep(1000);
           }catch(Exception e){
           }
        }
    }
}
//进行测试
  public static void a(){
        Thread threadA=new ThreadA();
        Thread threadB=new ThreadB();
        threadA.start();
        threadB.start();
    }

运行结果

通过实现Runnable接口来创建线程

//分别创建两个类实现Runnable接口
public class RunnableA implements Runnable {
    @Override
    public void run() {
for(int i=0;i<3;i++){
  //打出当前线程的名字
    System.out.println("b"+Thread.currentThread().getName()+"..."+i);
    try{
        Thread.sleep(1000);
    }catch(Exception e){
    }

}
    }
}

public class RunnableB implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println("a"+Thread.currentThread().getName()+"..."+i);
            try{
                Thread.sleep(1000);
            }catch(Exception e){
            }

        }
    }
}
//进行测试
public static void b(){
        Runnable runnableA=new RunnableA();
        Runnable runnableB=new RunnableB();
        Thread threadA=new Thread(runnableA);
        Thread threadB=new Thread(runnableB);
        threadA.start();
        threadB.start();
}

运行结果

通过Callable和Future创建线程

//分别创建两个类实现Runnable接口
import java.util.concurrent.Callable;
public class CallableA implements Callable {
    @Override
    public Object call() throws Exception {
        for(int i=0;i<2;i++){
            System.out.println("a"+Thread.currentThread().getName()+".."+i);
           try{
               Thread.sleep(1000);
           }catch(Exception e){
           }

        }
        return "a";
    }
}

public class CallableB implements Callable {
    @Override
    public Object call() throws Exception {
        for(int i=0;i<2;i++){
            System.out.println("b"+Thread.currentThread().getName()+".."+i);
           try{
               Thread.sleep(1000);
           }catch(Exception e){
           }
        }
        return "b";
    }
}
//进行测试
public static void c(){
    try{
        //先创建出Callable对象
        CallableA ca=new CallableA();
        CallableB cb=new CallableB();
        //将Callable对象--->FutureTask
    FutureTask ft1=new FutureTask(ca);
    FutureTask ft2=new FutureTask(cb);
    //将FutureTask--->Thread
    Thread t1=new Thread(ft1);
    Thread t2=new Thread(ft2);
    //输出Callable的return值
        t1.start();
        t2.start();
       Object ob1=ft1.get();
       Object ob2=ft2.get();
       System.out.println(ob1);
       System.out.println(ob2);
    }catch(Exception e){
   }

}

运行结果

三种创建方式的区别

采用实现Runnable、Callable接口的方式

i>线程类只是实现了Runnale、Callable接口，还可以继承其他类
ii>多个线程可以共享同一个target对象，非常适合多个相同的线程来处理同一份资源的情况,Callable可以有返回值
iii>编程复杂，如果需要访问当前线程，必须使用Thread.CurrentThread()方法

采用继承Thread类的方式

i>不能继承其他的父类
ii>编写简单，如果要访问当前线程，可以使用this