java多线程实现方式

1、继承Thread类,重写run()方法（其实Thread本身也实现了Runnable接口）；
2、实现Runnable接口，重写run（）方法；
3、实现Callable接口，重写call（）方法（有返回值）；
4、使用线程池（有返回值）；
一、
继承Thread类，重写run()方法
每次创建一个新的线程，都要新建一个Thread子类的对象；
启动线程，new Thread（）.start();
创建线程实际调用Thread空参构造器；

public class MyThread {

public static void main(String[] args) {
    for(int i=0; i < 10; i++){
        new ExtendsThread().start();
    }
}    

}
class ExtendsThread extends Thread{
@Override
public void run(){
System.out.println(Thread.currentThread().getName());
}
}

二、
实现Runnable接口，重写run方法

不论创建多少个线程，只需要创建一个Runnable接口实现类的对象

启动线程，new Thread（Runnable接口实现类的对象）.start()

创建线程调用的是Thread类Runable类型参数的构造器
public class MyThread {

public static void main(String[] args) {
    ImplRunnable runnable = new ImplRunnable();
    ImplRunnable runnable2 = new ImplRunnable();
    Thread t1 = new Thread(runnable); 
    Thread t2 = new Thread(runnable2); 
    t1.start();
    t2.start();
}

}

class ImplRunnable implements Runnable{

int count =0;
@Override
public void run(){
    while(true){
        System.out.println(Thread.currentThread().getName()+": "+count++);
        if(count>10){
            break;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  
}

}

三、
实现Callable接口，重写call方法（有返回值）

自定义类实现Callable接口时，必须指定泛型，该泛型即返回值的类型

每次创建一个新的线程，都要创建一个新的Callable接口的实现类、

如何启动线程？

（1）创建一个Callable接口的实现类的对象

（2）创建一个FutureTask对象，传入Callable类型的参数

public FutureTask(Callable callable){……}

（3）调用Thread类重载的参数为Runnable的构造器创建Thread对象

将FutureTask作为参数传递

public class FutureTask implements RunnableFuture

public interface RunnableFuture extends Runnable, Future

如何获取返回值？

调用FutureTask类的get()方法

public class MyThread {

public static void main(String[] args) throws InterruptedException, ExecutionException {
   for(int i = 0;i < 3; i++){
       Callable<Integer> implCallable = new ImplCallable(); 
       FutureTask<Integer> futureTask = new FutureTask<Integer>(implCallable);
       Thread t = new Thread(futureTask);
       t.start();
       System.out.println(Thread.currentThread().getName()+"------------"+futureTask.get());
   }
    System.out.println(Thread.currentThread().getName());
}

}

class ImplCallable implements Callable{

@Override
public Integer call() throws Exception {
    int result = 0;
    for(int i = 0; i < 10; i++){
        result += i;
    }
    System.out.println(Thread.currentThread().getName());
    
    return result;
}

}

三、线程池
/**
*

• 线程池
• 跟数据库连接池类似
• 避免了线程的创建和销毁造成的额外开销
• java.util.concurrent
• Executor 负责现成的使用和调度的根接口
• |–ExecutorService 线程池的主要接口

•      |--ThreadPoolExecutor    线程池的实现类
  

•      |--ScheduledExecutorService    接口，负责线程的调度
  

•          |--ScheduledThreadPoolExecutor    (extends ThreadPoolExecutor implements ScheduledExecutorService)
  

• Executors工具类
• 提供了创建线程池的方法

*/
public class ThreadPool {

public static void main(String[] args) {
   
  //使用Executors工具类中的方法创建线程池
    ExecutorService pool = Executors.newFixedThreadPool(5);

    ThreadPoolDemo demo = new ThreadPoolDemo();

    //为线程池中的线程分配任务,使用submit方法，传入的参数可以是Runnable的实现类，也可以是Callable的实现类
    for(int i=1;i<=5;i++){
        pool.submit(demo);
    }

    //关闭线程池
    //shutdown ： 以一种平和的方式关闭线程池，在关闭线程池之前，会等待线程池中的所有的任务都结束，不在接受新任务
    //shutdownNow ： 立即关闭线程池
    pool.shutdown();

}

}

class ThreadPoolDemo implements Runnable{

/**多线程的共享数据*/
private int i = 0;

@Override
public void run() {
    while(i<=50){
        System.out.println(Thread.currentThread().getName()+"---"+ i++);
    }
}

}

public class ThreadPool2 {

public static void main(String[] args) {
   ExecutorService executorService = Executors.newFixedThreadPool(5);
    
    for(int i=0;i<5;i++){
        Future<Integer> future = executorService.submit(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                int result = 0;
                for(int i=0;i<=10;i++){
                    result += i;
                }
                return result;
            }
        });
        
        try {
            System.out.println(Thread.currentThread().getName()+"--"+future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
    
    executorService.shutdown();

}

}