java线程创建3种方式_JAVA基础—创建线程的3种方式

线程的生命周期(五种状态)

线程的五种状态

创建线程的三种方式对比

对比

继承Thread

实现Runnable

实现线程池 Callable

优点

编程简单，执行效率高

面向接口编程，执行效率高

容器管理线程，允许返回值与异常

缺点

单继承，无法对线程组有效控制

无法对线程组有效控制，没有返回值、异常

执行效率相对较低，编程麻烦

使用场景

不推荐使用

简单的多线程程序

企业级应用，推荐使用

1. 创建多线程-继承Thread

public class Match1 {

public static void main(String[] args) {

//创建一个新的线程

Runner1 lx = new Runner1();

//设置线程名称

lx.setName("刘翔");

Runner1 mr = new Runner1();

mr.setName("鸣人");

Runner1 lf = new Runner1();

lf.setName("路飞");

//启动线程

lx.start();

mr.start();

lf.start();

}

}

class Runner1 extends Thread {

//继承线程的 run()方法

@Override

public void run() {

Integer speed = new Random().nextInt(100);

for (int i = 1; i <= 100; i++) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(this.getName() + "已前进" + (i * speed) + "米(" + speed +"米/秒)");

}

}

}

运行结果

...

鸣人已前进2376米(24米/秒)

刘翔已前进2574米(26米/秒)

路飞已前进2376米(24米/秒)

鸣人已前进2400米(24米/秒)

刘翔已前进2600米(26米/秒)

路飞已前进2400米(24米/秒)

2. 创建多线程-实现Runnable接口

public class Match2 {

public static void main(String[] args) {

Runner2 lx = new Runner2();

Thread thread1 = new Thread(lx);

thread1.setName("刘翔");

Thread mr = new Thread(new Runner2());

mr.setName("鸣人");

Thread lf = new Thread(new Runner2());

lf.setName("路飞");

thread1.start();

mr.start();

lf.start();

}

}

class Runner2 implements Runnable{

@Override

public void run() {

Integer speed = new Random().nextInt(100);

for (int i = 1; i <= 100; i++) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "已前进" + (i * speed) + "米(" + speed +"米/秒)");

}

}

}

运行结果

...

鸣人已前进4257米(43米/秒)

刘翔已前进2970米(30米/秒)

路飞已前进5346米(54米/秒)

刘翔已前进3000米(30米/秒)

鸣人已前进4300米(43米/秒)

路飞已前进5400米(54米/秒)

3. 创建多线程-实现Callable接口

public class Match3 {

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

//创建一个线程，里面定义了3个“空线程”。 Executors调度器，对线程进行管理

ExecutorService executorService = Executors.newFixedThreadPool(3);

//实例化Callable对象

Runner3 liuxiang = new Runner3();

liuxiang.setName("刘翔");

Runner3 mr = new Runner3();

mr.setName("鸣人");

Runner3 lf = new Runner3();

lf.setName("路飞");

//将这个对象扔到线程池中，线程池自动分配一个线程池来运行liuxiang这个对象的call方法

//Future用于接收线程内部call方法的返回值

Future result1 = executorService.submit(liuxiang);

Future result2 = executorService.submit(mr);

Future result3 = executorService.submit(lf);

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

//关闭线程池释放所有资源

executorService.shutdown();

System.out.println("刘翔累计跑了" + result1.get() + "米");

System.out.println("鸣人累计跑了" + result2.get() + "米");

System.out.println("路飞累计跑了" + result3.get() + "米");

}

}

class Runner3 implements Callable {

//concurrent包没有getName 所以在类里自定义name

private String name;

public void setName(String name){

this.name = name;

}

//实现Callable接口可以允许我们的线程返回值或抛出异常

@Override

public Integer call() throws Exception {

Integer speed = new Random().nextInt(100);

Integer distince = 0; //总共奔跑的距离

for (int i = 1; i <= 100; i++) {

Thread.sleep(10);

distince = i * speed;

//打印已跑多少米

System.out.println(this.name + "已前进" + distince + "米("+speed+"米/秒)");

}

return distince;

}

}

运行结果

...

刘翔累计跑了2300米

鸣人累计跑了2900米

路飞累计跑了4100米