java生成线程的四种方式

1、继承Thread类+重写run()方法

启动：创建子类对象+对象.start()

缺点：Java只支持单继承，如果我们的类已经从一个类继承，则无法再继承Thread类。

/**
* 模拟龟兔赛跑
* 1、创建多线程（方式一）：继承 Thread + 重写run方法（线程体）
* 2、使用线程：创建子类对象  + 对象.start()方法  线程启动
*/

public class Demo01 {

public static void main(String[] args) {
//创建子类对象
Rabbit rab = new Rabbit();
Tortoise tor = new Tortoise();
//调用start方法 ，启动线程。 内部由CPU管控
rab.start(); //不要调用run方法，由内部自己调用。
tor.start();
for(int i=0;i<30;i++)
{
System.out.println("main-->"+i);
}
}
}

class Rabbit extends Thread{
//线程体  一切从run开始
@Override
public void run() {
//线程体
for(int i=0;i<30;i++)
{
System.out.println("兔子跑了"+i+"步");
}
}

}

class Tortoise extends Thread
{
@Override
public void run() {
//线程体
for(int i=0;i<30;i++)
{
System.out.println("乌龟跑了"+i+"步");
}
}
}

2、实现Runnable接口+重写run方法

启动：使用静态代理

1)、创建真实角色

2)、创建代理角色

3)、调用start()方法 启动线程

优点：可以同时实现继承，Runnable接口方式更加通用一些。

1、避免单继承的局限性

2、便于共享资源

通过实现Runnable接口实现多线程。（用到了静态代理设计模式）

/**
* 推荐使用Runnable创建线程
* 1、避免单继承的局限性
* 2、便于共享资源
*/
public class Demo03 {
public static void main(String[] args) {
//1)、创建真实角色
Programmer pro = new Programmer();
//2)、创建代理角色+真实角色引用
Thread proxy = new Thread(pro);
//3)、调用start()方法 启动线程
proxy.start();

for(int i=0;i<100;i++){
System.out.println("一边聊QQ");
}
}
}

/**
* 使用Runnable 创建进程
* 1、类实现Runable接口+重写run()方法
* 2、启动多线程 使用静态代理
*      1)、创建真实角色
*      2)、创建代理角色
*      3)、调用start()方法 启动线程
*/
class Programmer implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println("一边敲代码");
}
}
}

/**
* 抢票系统
* 方便共享资源
*/
public class Demo04 implements Runnable{
private int num = 50;
@Override
public void run() {
while(true){
if(num<=0)
{
break;//跳出循环
}
System.out.println(Thread.currentThread().getName()+"抢到了倒数第"+num--+"张。");
}
}

public static void main(String[] args) {
//真实角色
Demo04 web = new Demo04();
//代理
Thread t1 = new Thread(web,"德玛西亚");
Thread t2 = new Thread(web,"卡特琳娜");
Thread t3 = new Thread(web,"德邦总管");

//启动线程
t1.start();
t2.start();
t3.start();
}
}

3、使用Callable接口创建多线程

Callable 和 Future接口

Callable是类似于Runnable的接口，实现*Callable接口的类和实现Runnable的类都是可被其它线程执行的任务*。

优点：可以返回值，可以抛异常。

缺点：实现繁琐。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
* 使用Callable接口方式创建多线程
*/
public class Demo05 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//1、创建线程
ExecutorService ser = Executors.newFixedThreadPool(2);//开两个线程

Race tortoise = new Race("老乌龟",1000);
Race rabbit = new Race("小兔子",500);

//2、获取Future对象
Future<integer> result1 = ser.submit(tortoise);
Future<integer> result2 = ser.submit(rabbit);

Thread.sleep(2000);//2秒
tortoise.setFlag(false);//停止线程体循环 设置flag = false;
rabbit.setFlag(false);
//3、获取值
int num1 = result1.get();
int num2 = result2.get();

System.out.println("乌龟跑了-->"+num1+"步");
System.out.println("兔子跑了-->"+num2+"步");
//4、停止服务
ser.shutdownNow();
}
}

class Race implements Callable<integer>
{
private String name;//名称
private long time;//延时时间
private boolean flag = true;
private int step = 0;//步

public Race() {
}
public Race(String name) {
super();
this.name = name;
}
public Race(String name, int time) {
super();
this.name = name;
this.time = time;
}

//有返回值了
@Override
public Integer call() throws Exception {
while(flag){
Thread.sleep(time);//延时
step++;
}
return step;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getTime() {
return time;
}
public void setTime(long  time) {
this.time = time;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public int getStep() {
return step;
}
public void setStep(int step) {
this.step = step;
}
}

4、应用程序可以使用Executor框架来创建线程池

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

public class ThreadPool {
private  static int POOL_NUM = 10;
public static void main(String[] agrs){
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < POOL_NUM; i++) {
RunnableThread thread = new RunnableThread();
executorService.execute(thread);
}
}
}
class RunnableThread implements  Runnable{
private   int THREAD_NUM = 10;
public void run() {
for (int i = 0; i <THREAD_NUM; i++) {
System.out.println("线程"+Thread.currentThread()+i);
}

}
}

几种方式的比较：

Callable和Runnable有几点不同：

（1）Callable规定的方法是call()，而Runnable规定的方法是run().

（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

（3）call()方法可抛出异常，而run()方法是不能抛出异常的。

（4）运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。

实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。