Java创建线程的四种方式

1.继承Thread类实现多线程

public class MyThread extends Thread { public MyThread() { } public void run() { for(int i=0;i<10;i++) { System.out.println(Thread.currentThread()+":"+i); } } public static void main(String[] args) { MyThread mThread1=new MyThread(); MyThread mThread2=new MyThread(); MyThread myThread3=new MyThread(); mThread1.start(); mThread2.start(); myThread3.start(); } }

2.覆写Runnable()接口实现多线程，而后同样覆写run().推荐此方式

public class MyThread implements Runnable{ public static int count=20; public void run() { while(count>0) { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"-当前剩余票数:"+count--); } } public static void main(String[] args) { MyThread Thread1=new MyThread(); Thread mThread1=new Thread(Thread1,"线程1"); Thread mThread2=new Thread(Thread1,"线程2"); Thread mThread3=new Thread(Thread1,"线程3"); mThread1.start(); mThread2.start(); myThread3.start(); } } 

继承Thread和实现Runnable接口的区别

3.覆写Callable接口实现多线程（JDK1.5）

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class MyThread implements Callable 
  
    { private int count = 20; @Override public String call() throws Exception { for (int i = count; i > 0; i--) { // Thread.yield(); System.out.println(Thread.currentThread().getName()+"当前票数：" + i); } return "sale out"; } public static void main(String[] args) throws InterruptedException, ExecutionException { Callable 
   
     callable =new MyThread(); FutureTask 
    
      futureTask=new FutureTask<>(callable); Thread mThread=new Thread(futureTask); Thread mThread2=new Thread(futureTask); Thread mThread3=new Thread(futureTask); // mThread.setName("hhh"); mThread.start(); mThread2.start(); mThread3.start(); System.out.println(futureTask.get()); } } 
     
    
  

4.通过线程池启动多线程

通过Executor 的工具类可以创建三种类型的普通线程池：

FixThreadPool(int n); 固定大小的线程池

 使用于为了满足资源管理需求而需要限制当前线程数量的场合。使用于负载比较重的服务器。

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex=Executors.newFixedThreadPool(5); for(int i=0;i<5;i++) { ex.submit(new Runnable() { @Override public void run() { for(int j=0;j<10;j++) { System.out.println(Thread.currentThread().getName()+j); } } }); } ex.shutdown(); } }

SingleThreadPoolExecutor :单线程池

需要保证顺序执行各个任务的场景 

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex=Executors.newSingleThreadExecutor(); for(int i=0;i<5;i++) { ex.submit(new Runnable() { @Override public void run() { for(int j=0;j<10;j++) { System.out.println(Thread.currentThread().getName()+j); } } }); } ex.shutdown(); } }

CashedThreadPool(); 缓存线程池

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { public static void main(String[] args) { ExecutorService ex=Executors.newCachedThreadPool(); for(int i=0;i<5;i++) { ex.submit(new Runnable() { @Override public void run() { for(int j=0;j<10;j++) { System.out.println(Thread.currentThread().getName()+j); } } }); } ex.shutdown(); } } 

线程之间的状态，及他们之间的相互转换