在Java中，线程的知识是很重要的，线程其实就是进程中的一个执行流程，一个进程中可以运行多个线程，那java如何创建线程?下面来我们就来给大家讲解一下java创建线程的四种方式。
1.继承Thread类实现多线程
run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口
a.一个线程调用 两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次
b.native生明的方法只有方法名，没有方法体。是本地方法，不是抽象方法，而是调用c语言方法
registerNative()方法包含了所有与线程相关的操作系统方法
c. run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用(否则就是普通方法)
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().推荐此方式
a.覆写Runnable接口实现多线程可以避免单继承局限
b.当子类实现Runnable接口，此时子类和Thread的代理模式(子类负责真是业务的操作，thread负责资源调度与线程创建辅助真实业务。
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接口的区别
a.实现Runnable接口避免多继承局限
b.实现Runnable()可以更好的体现共享的概念
3.覆写Callable接口实现多线程(JDK1.5)
a.核心方法叫call()方法，有返回值
b.有返回值
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
{
Callablecallable = new MyThread();
FutureTaskfutureTask = 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();
}
}java创建线程就是以上四种方法，线程在java编程中的作用可以实现多个任务同时进行，因此线程在java中的地位是何等的重要哦!最后大家如果想要了解更多java入门知识，敬请关注奇Q工具网。
推荐阅读：