创建多线程

多线程的创建有多种方式，分别是：

创建方式	优点	缺点
继承Thread类创建线程	使用简单	无法再继承其他类
实现Runnable接口创建线程	可以继承多个接口	比较复杂，无返回值
实现Callable接口	有返回值，可以继承多个接口	比较复杂

方法一：

方法1：继承Thread类方法：
/**
1.自定义一个类，继承java.lang包下的Thread类
2.重写run方法
3.将要在线程中执行的代码编写在run方法中
4.创建上面自定义类的对象
5.调用start方法启动线程
 */
class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0; i<1000; i++){
            System.out.println("a");
        }
    }
}

public class ThreadTest01 {
    public static void main(String[] args){
        MyThread mt = new MyThread();
        mt.start();
        for(int i=0; i<1000; i++){
            System.out.println("b");
        }
    }
}

方法二实现Runnable接口：

/*
 * 1.自定义一个类实现java.lang包下的Runnable接口
2.重写run方法
3.将要在线程中执行的代码编写在run方法中
4.创建上面自定义类的对象
5.创建Thread对象并将上面自定义类的对象作为参数传递给Thread的构造方法
6.调用start方法启动线程
*/
class MyRunnable implements Runnable {
    @Override
    public void run(){
        for(int i=0; i<1000; i++){
            System.out.println("a");
        }
    }
}
public class ThreadTest02 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr); 
        t.start();
         for (int i = 0; i < 1000; i++) {
                System.out.println("1024");
            }
    }

}

方法三使用Callable接口：

package test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/* 1.自定义一个类实现java.util.concurrent包下的Callable接口
2.重写call方法
3.将要在线程中执行的代码编写在call方法中
4.创建ExecutorService线程池
5.将自定义类的对象放入线程池里面
6.获取线程的返回结果
7.关闭线程池，不再接收新的线程，未执行完的线程不会被关闭*/
class MyCallable implements Callable<Integer>{
     private int count;
     
     public MyCallable(int count){
         this.count = count;
     }
    
    @Override
     public Integer call() throws Exception{
        int sum=1;
        if(count != 0){
            for(int i=1; i<= count; i++){
                sum *= i;
            }
        }else{
            sum = 0;
        }
          System.out.println(Thread.currentThread().getName() + "-----sum=" + sum);
        return sum;
     }
}


public class ThreadTest03 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // TODO Auto-generated method stub
        //创建线程池
        //ExecutorService es = Executors.newFixedThreadPool(2);
        //创建一个大小不固定的线程池，里面的线程会根据任务数量进行添加，资源耗费较大
        ExecutorService es = Executors.newCachedThreadPool();
        
        Future<Integer> f1 = es.submit(new MyCallable(5));
        Future<Integer> f2 = es.submit(new MyCallable(3));
        
        System.out.println(f1.get());
        System.out.println(f2.get());
//        
        es.isShutdown();
        
        //判断线程是否执行完毕
//        System.out.println("F1:" + f1.isDone());
//        System.out.println("F2:" + f2.isDone());
        
        System.out.println("main方法执行结束");
    }

}

方法1：继承Thread类方法：

/**

1.自定义一个类，继承java.lang包下的Thread类

2.重写run方法

3.将要在线程中执行的代码编写在run方法中

4.创建上面自定义类的对象

5.调用start方法启动线程

 */

class MyThread extends Thread{

   @Override

   publicvoid run(){

      for(inti=0; i<1000; i++){

          System.out.println("a");

      }

   }

}

 

publicclass ThreadTest01 {

   publicstaticvoid main(String[] args){

      MyThread mt = new MyThread();

      mt.start();

      for(inti=0; i<1000; i++){

          System.out.println("b");

      }

   }

}