Java多线程实现的方式有四种

Java多线程实现的方式有四种

1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程

前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果

后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

方式1：继承Thread类的线程实现方式如下：

Thread

ublic void testThread(){
    Thread thread=new Thread(){
        @Override
        public void run() {
            System.out.println("test Thread"+this.getName());
        }
    };
    thread.start();
    System.out.println("main..."+Thread.currentThread().getName());
}

线程实现方式2：通过实现Runnable接口，实现run方法，接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数，通过调用start()方法启动线程

Runnable

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("test Runable"+Thread.currentThread().getName());
    }
};
Thread thread=new Thread(runnable);
thread.start();
System.out.println("main..."+Thread.currentThread().getName());

线程实现方式3：通过Callable和FutureTask创建线程

Callable

Callable callable=new Callable<String>(){

    @Override
    public String call() throws Exception {
        System.out.println("test Callable"+Thread.currentThread().getName());
        return "success";
    }
};
FutureTask futureTask=new FutureTask(callable);
Thread thread=new Thread(futureTask);
thread.start();
try {
    Object o = futureTask.get();
    System.out.println(o.toString());
} catch (InterruptedException e) {
} catch (ExecutionException e) {
}
System.out.println("main..."+Thread.currentThread().getName());

线程实现方式4：通过线程池创建线程

ExecutorService threadPool = Executors.newFixedThreadPool(10);
for (int i=0;i<1000;i++){
    Runnable runnable=new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"run");
        }
    };
    threadPool.execute(runnable);
}
//关闭线程池
threadPool.shutdown();

*异步编排

Executors 线程池

//sum=1+2+...+100
//创建连接池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.MINUTES,
        new LinkedBlockingQueue(), Executors.defaultThreadFactory()
        , new ThreadPoolExecutor.DiscardOldestPolicy());

CompletableFuture<Integer> futrue1 = CompletableFuture.supplyAsync(() -> {
    int sum = 0;
    for (int i = 0; i <= 50; i++) {
        sum += i;
    }
    return sum;
},threadPoolExecutor);
CompletableFuture<Integer> futrue2 = CompletableFuture.supplyAsync(() -> {
    int sum = 0;
    for (int i = 51; i <= 100; i++) {
        sum += i;
    }
    return sum;
 },threadPoolExecutor);
CompletableFuture.allOf(futrue1,futrue2).get();
System.out.println("1+2+...+100="+(futrue1.get()+futrue2.get()));