如何在类中创建线程 在C里面如何创建线程…

(在手机横屏上查看源代码更方便)

问题

(1)如何创建线程？

(2)他们各自有什么使用情景？

简介

创建线程是多线程编程中最基本的任务。通型总结了大约8种线程的制作方法。你知道吗？

继承Thread类并重写run()方法

public class creating thread 01 extends thread {

@Override

Public void run() {

sy(get name()' is running ')；

}

public static void main(string[]args){

New CreatingThread01()。START()；

New CreatingThread01()。START()；

New CreatingThread01()。START()；

New CreatingThread01()。START()；

}

}

继承Thread类并重写run()方法。这种方法的缺点是类只能继承一个超类。如果类本身已经继承了另一个类，则不可用。

实现Runnable接口

public class CreatingThread02 implements Runnable {
@Override
public void run() {
Sy().getName() + " is running");
}
public static void main(String[] args) {
new Thread(new CreatingThread02()).start();
new Thread(new CreatingThread02()).start();
new Thread(new CreatingThread02()).start();
new Thread(new CreatingThread02()).start();
}
}

实现Runnable接口，这种方式的好处是一个类可以实现多个接口，不影响其继承体系。

匿名内部类

public class CreatingThread03 {
public static void main(String[] args) {
// Thread匿名类，重写Thread的run()方法
new Thread() {
@Override
public void run() {
Sy(getName() + " is running");
}
}.start();
// Runnable匿名类，实现其run()方法
new Thread(new Runnable() {
@Override
public void run() {
Sy().getName() + " is running");
}
}).start();

// 同上，使用lambda表达式函数式编程
new Thread(()->{
Sy().getName() + " is running");
}).start();
}
}

使用匿名类的方式，一是重写Thread的run()方法，二是传入Runnable的匿名类，三是使用lambda方式，现在一般使用第三种（java8+），简单快捷。

实现Callabe接口

public class CreatingThread04 implements Callable<Long> {
@Override
public Long call() throws Exception {
T(2000);
Sy().getId() + " is running");
return T().getId();
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<Long> task = new FutureTask<>(new CreatingThread04());
new Thread(task).start();
Sy("等待完成任务");
Long result = ();
Sy("任务结果：" + result);
}
}

实现Callabe接口，可以获取线程执行的结果，FutureTask实际上实现了Runnable接口。

定时器（java.u）

public class CreatingThread05 {
public static void main(String[] args) {
Timer timer = new Timer();
// 每隔1秒执行一次
(new TimerTask() {
@Override
public void run() {
Sy().getName() + " is running");
}
}, 0 , 1000);
}
}

使用定时器java.u可以快速地实现定时任务，TimerTask实际上实现了Runnable接口。

线程池

public class CreatingThread06 {
public static void main(String[] args) {
ExecutorService threadPool = Execu(5);
for (int i = 0; i < 100; i++) {
(()-> Sy().getName() + " is running"));
}
}
}

使用线程池的方式，可以复用线程，节约系统资源。

并行计算（Java8+）

public class CreatingThread07 {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 串行，打印结果为12345
li().forEach(System.out::print);
Sy();
// 并行，打印结果随机，比如35214
li().forEach(System.out::print);
}
}

使用并行计算的方式，可以提高程序运行的效率，多线程并行执行。

Spring异步方法

首先，springboot启动类加上@EnableAsync注解（@EnableAsync是spring支持的，这里方便举例使用springboot）。

@SpringBootApplication
@EnableAsync
public class Application {
public static void main(String[] args) {
S, args);
}
}

其次，方法加上@Async注解。

@Service
public class CreatingThread08Service {
@Async
public void call() {
Sy().getName() + " is running");
}
}

然后，测试用例直接跟使用一般的Service方法一模一样。

@RunWi)
@SpringBootTest(classes = A)
public class CreatingThread08Test {
@Autowired
private CreatingThread08Service creatingThread08Service;
@Test
public void test() {
crea();
crea();
crea();
crea();
}
}

运行结果如下：

task-3 is running
task-2 is running
task-1 is running
task-4 is running

可以看到每次执行方法时使用的线程都不一样。

使用Spring异步方法的方式，可以说是相当地方便，适用于前后逻辑不相关联的适合用异步调用的一些方法，比如发送短信的功能。

总结

（1）继承Thread类并重写run()方法；

（2）实现Runnable接口；

（3）匿名内部类；

（4）实现Callabe接口；

（5）定时器（java.u）；

（6）线程池；

（7）并行计算（Java8+）；

（8）Spring异步方法；

彩蛋

上面介绍了那么多创建线程的方式，其实本质上就两种，一种是继承Thread类并重写其run()方法，一种是实现Runnable接口的run()方法，那么它们之间到底有什么联系呢？

请看下面的例子，同时继承Thread并实现Runnable接口，应该输出什么呢？

public class CreatingThread09 {
public static void main(String[] args) {
new Thread(()-> {
Sy("Runnable: " + T().getName());
}) {
@Override
public void run() {
Sy("Thread: " + getName());
}
}.start();
}
}

说到这里，我们有必要看一下Thread类的源码：

public class Thread implements Runnable {
// Thread维护了一个Runnable的实例
private Runnable target;

public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}

public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
// …
// 构造方法传进来的Runnable会赋值给target
= target;
// …
}

@Override
public void run() {
// Thread默认的run()方法，如果target不为空，会执行target的run()方法
if (target != null) {
();
}
}
}

看到这里是不是豁然开朗呢？既然上面的例子同时继承Thread并实现了Runnable接口，根据源码，实际上相当于重写了Thread的run()方法，在Thread的run()方法时实际上跟target都没有关系了。

所以，上面的例子输出结果为Thread: Thread-0，只输出重写Thread的run()方法中的内容。