Java创建线程的方式有几种？

1.继承Thread类实现多线程

run（）为线程类的核心方法，相当于主线程的main（）方法，是每个线程的入口
(1)一个线程调用两次start（）方法将会抛出线程状态异常，也就是start（）只可以调用一次
(2)native声明的方法只有方法名，没有方法体。是本地方法，不是抽象方法，而是调用c语言方法，registerNative（）方法包含了所有与线程相关的操作系统方法
(3)run（）方法是由JVM创建完本地操作系统及线程后回调的方法，不可以手动调用，通过start调用

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

2.实现Runnable（）接口实现多线程

Runnable接口实现多线程可以避免单继承局限。
当子类实现Runnable接口，此时子类和Thread属于代理模式（子类负责真实业务的操作，Thread负责资源调度与线程创建辅助真实业务）。

public class MyThread1 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){
MyThread1 myThread1=new MyThread1();
Thread m1=new Thread(myThread1,“线程1”);
Thread m2=new Thread(myThread1,“线程2”);
Thread m3=new Thread(myThread1,“线程3”);
m1.start();
m2.start();
m3.start();
}
}

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

核心方法叫call（）方法，有返回值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyThread2 implements Callable{
private int count=20;
@Override
public String call() throws Exception{
for(int i=count;i>0;i–){
System.out.println(Thread.currentThread().getName()+“当前票数:”+i);
}
return “sale out”;
}
public static void main(String[] args) throws InterruptedException,ExecutionException{
Callable callable=new MyThread2();
FutureTask futureTask=new FutureTask<>(callable);
Thread m4=new Thread(futureTask);
Thread m5=new Thread(futureTask);
Thread m6=new Thread(futureTask);
m4.start();
m5.start();
m6.start();
System.out.println(futureTask.getName());
}
}

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 Tes1{
public static void main(String[] args){
ExecutorService ex1=Executors.newSingleThreadExecutor();
for(int i=0;i<5;i++){
ex1.submit(new Runnable(){
@Override
public void run(){
for(int j=0;j<10;j++){
System.out.println(Thread.currentThread().getName()+j);
}
}
});
}
ex1.shutdown();
}
}

CashedThreadPool():缓存线程池
当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程，适用于提交短期异步小程序，以及负载较轻的服务器。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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