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

    }

}