Java创建多线程的8种方式集合

//方式1

package cn.itcats.thread.Test1;

public class Demo1 extends Thread{

     //重写的是父类Thread的run()

  public void run() {

   System.out.println(getName()+ "is running..." );

  } 

  public static void main(String[] args) {

   Demo1 demo1 = new Demo1();

   Demo1 demo2 = new Demo1();

   demo1.start();

   demo2.start();

  }

}

//Thread类源码中的run()方法

//target为Thread 成员变量中的 private Runnable target;

  @Override

     public void run() {

         if (target != null ) {

             target.run();

         }

     }

package cn.itcats.thread.Test1;

/**

  * 第二种创建启动线程的方式

  * 实现Runnale接口

  * @author fatah

  */

public class Demo2 implements Runnable{

     //重写的是Runnable接口的run()

  public void run() {

    System.out.println( "implements Runnable is running" );

  }

  public static void main(String[] args) {

   Thread thread1 = new Thread( new Demo2());

   Thread thread2 = new Thread( new Demo2());

   thread1.start();

   thread2.start();

  }

}

package cn.itcats.thread.Test1;

/**

  * 创建启动线程的第三种方式————匿名内部类

  * @author fatah

  */

public class Demo3 {

  public static void main(String[] args) {

   //方式1：相当于继承了Thread类，作为子类重写run()实现

   new Thread() {

    public void run() {

     System.out.println( "匿名内部类创建线程方式1..." );

    };

   }.start(); 

   //方式2:实现Runnable,Runnable作为匿名内部类

   new Thread( new Runnable() {

    public void run() {

     System.out.println( "匿名内部类创建线程方式2..." );

    }

   } ).start();

  }

}

package cn.itcats.thread.Test1;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Future;

import java.util.concurrent.FutureTask;

import java.util.concurrent.RunnableFuture;

/**

  * 方式4:实现Callable<T> 接口

  * 含返回值且可抛出异常的线程创建启动方式

  * @author fatah

  */

public class Demo5 implements Callable<String>{

  public String call() throws Exception {

   System.out.println( "正在执行新建线程任务" );

   Thread.sleep( 2000 );

   return "新建线程睡了2s后返回执行结果" ;

  }

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

   Demo5 d = new Demo5();

   /* call()只是线程任务,对线程任务进行封装

    class FutureTask<V> implements RunnableFuture<V>

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

   */

   FutureTask<String> task = new FutureTask<>(d);

   Thread t = new Thread(task);

   t.start();

   System.out.println( "提前完成任务..." );

   //获取任务执行后返回的结果

   String result = task.get();

   System.out.println( "线程执行结果为" +result);

  }

}

package cn.itcats.thread.Test1;

import java.util.Timer;

import java.util.TimerTask;

/**

  * 方法5：创建启动线程之Timer定时任务

  * @author fatah

  */

public class Demo6 {

     public static void main(String[] args) {

         Timer timer = new Timer();

         timer.schedule( new TimerTask() {

             @Override

             public void run() {

                 System.out.println( "定时任务延迟0(即立刻执行),每隔1000ms执行一次" );

             }

         }, 0 , 1000 );

     }  

}

package cn.itcats.thread.Test1;

import java.util.concurrent.Executor;

import java.util.concurrent.Executors;

public class Demo7 {

  public static void main(String[] args) {

   //创建带有5个线程的线程池

   //返回的实际上是ExecutorService,而ExecutorService是Executor的子接口

   Executor threadPool = Executors.newFixedThreadPool( 5 );

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

    threadPool.execute( new Runnable() {

     public void run() {

      System.out.println(Thread.currentThread().getName()+ " is running" );

     }

    });

   } 

  }

}

Executor threadPool = Executors.newFixedThreadPool( 10 );

ExecutorService threadPool = Executors.newFixedThreadPool( 10 );

package cn.itcats.thread.Test1;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

/**

  * 使用Lambda表达式并行计算

  * parallelStream

  * @author fatah

  */

public class Demo8 {

  public static void main(String[] args) {

   List<Integer> list = Arrays.asList( 1 , 2 , 3 , 4 , 5 , 6 );

   Demo8 demo = new Demo8();

   int result = demo.add(list);

   System.out.println( "计算后的结果为" +result);

  }

  public int add(List<Integer> list) {

   //若Lambda是串行执行,则应顺序打印

   list.parallelStream().forEach(System.out :: println);

   //Lambda有stream和parallelSteam(并行)

   return list.parallelStream().mapToInt(i -> i).sum();

  }

}

package cn.itcats.thread;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.annotation.EnableAsync;

@Configuration

@ComponentScan ( "cn.itcats.thread" )

@EnableAsync

public class Config {

}

package cn.itcats.thread;

import org.springframework.scheduling.annotation.Async;

import org.springframework.stereotype.Service;

@Service

public class AsyncService {

  @Async

  public void Async_A() {

   System.out.println( "Async_A is running" );

  }

  @Async

  public void Async_B() {

   System.out.println( "Async_B is running" );

  }

}

package cn.itcats.thread;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Run {

  public static void main(String[] args) {

   //构造方法传递Java配置类Config.class

   AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config. class );

   AsyncService bean = ac.getBean(AsyncService. class );

   bean.Async_A();

   bean.Async_B();

  }

}