多线程有几种实现方法_Java多线程实现有哪几种方法？

1.继承Thread类，重写run方法（其实Thread类本身也实现了Runnable接口）

2.实现Runnable接口，重写run方法

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

4.使用线程池（有返回值）

1.继承Thread类，重写run方法

　　每次创建一个新的线程，都要新建一个Thread子类的对象

　　启动线程，new Thread子类（）.start（）

　　创建线程实际调用的是父类Thread空参的构造器

public class MyThread {

public static void main(String ards[]){

for(int i=0;i<10;i++){

new ExtendsThread().start();

}

System.out.println(Thread.currentThread().getName());

}

}

class ExtendsThread extends Thread{

@Override

public void run() {

System.out.println(Thread.currentThread().getName());

}

}

2.实现Runnable接口，重写run方法

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

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

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

public class MyThread {

public static void main(String ards[]){

Runnable implRunnable = new ImplRunnable();

for(int i=0;i<10;i++){

new Thread(implRunnable).start();

}

System.out.println(Thread.currentThread().getName());

}

}

class ImplRunnable implements Runnable{

private volatile int i = 0;

@Override

public void run() {

System.out.println(Thread.currentThread().getName()+"--"+ i++);

}

}

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

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

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

　　如何启动线程？

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

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

　　　　　　　　public FutureTask(Callable<V> callable){……}

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

　　　　　　　　将FutureTask作为参数传递

　　　　　　　　public class FutureTask<V> implements RunnableFuture<V>

　　　　　　　　public interface RunnableFuture<V> extends Runnable, Future<V>

　　如何获取返回值？

　　　　调用FutureTask类的get()方法

public class MyThread {

public static void main(String ards[]) throws InterruptedException, ExecutionException{

for(int i=0;i<10;i++){

Callable<Integer> implCallable = new ImplCallable();

FutureTask<Integer> futureTask = new FutureTask<Integer>(implCallable);

new Thread(futureTask).start();

System.out.println(Thread.currentThread().getName()+"----"+futureTask.get());

}

System.out.println(Thread.currentThread().getName());

}

}

class ImplCallable implements Callable<Integer>{

@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;

}

}

4.线程池

Executors类

/**

*

* 线程池

* 跟数据库连接池类似

* 避免了线程的创建和销毁造成的额外开销

*

* 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();

}

}