在java开发中，经常会涉及多线程的编码，那么通过直接或间接创建线程的方法有哪些？现整理如下：
1、继承Thread类，重写run()方法
class Worker extends Thread {
@Override
public void run() {
System.out.println("Code run in a sub thread!");
}
}
public class CreateThreadTester {
public static void main(String[] args) throws InterruptedException {
Thread t = new Worker();
t.start();
t.join();
}
}
2、实现Runnable接口，重写run()
class Worker implements Runnable {
@Override
public void run() {
System.out.println("Code run in a sub thread!");
}
}
public class CreateThreadTester {
public static void main(String[] args) throws InterruptedException {
Runnable task = new Worker();
Thread t = new Thread(task);
t.start();
t.join();
}
}
3、实现Callable接口，重写call()
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class Worker implements Callable<Integer> {
@Override
public Integer call() {
System.out.println("Code run in a sub thread!");
return Integer.valueOf(10);
}
}
public class CreateThreadTester {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Callable<Integer> thread = new Worker();
FutureTask<Integer> task = new FutureTask<Integer>(thread);
Thread t = new Thread(task);
t.start();
System.out.println("Thread return value:" + task.get());
}
}
4、使用定时器
（1）基于类java.util.Timer和重写TimerTask的run()执行定时任务
示例代码如下：
import java.util.Timer;
import java.util.TimerTask;
class Worker extends TimerTask {
@Override
public void run() {
System.out.println("Code run in a sub thread!");
}
}
public class CreateThreadTester {
public static void main(String[] args) {
Timer timer = new Timer();
TimerTask task = new Worker();
timer.schedule(task, 0);
}
}
(2) 基于java.util.concurrent.Executors.newSingleThreadScheduledExecutor()执行定时任务
示例代码如下：
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadScheduledExecutorTester01 {
private static ThreadLocal<SimpleDateFormat> dateFormat = new ThreadLocal<SimpleDateFormat>() {
public SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
};
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
service.schedule(new Runnable() {
@Override
public void run() {
System.out.println(dateFormat.get().format(new Date()) + " -- 11111111111111");
}
}, 2, TimeUnit.SECONDS);
service.schedule(new Runnable() {
@Override
public void run() {
System.out.println(dateFormat.get().format(new Date()) + " -- 22222222222222222222");
}
}, 2, TimeUnit.SECONDS);
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(dateFormat.get().format(new Date()) + " -- 3333333333333333333333");
}
}, 1, 5, TimeUnit.SECONDS);
}
}
5、使用java.util.concurrent.Executors工厂类
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Worker implements Runnable {
@Override
public void run() {
System.out.println("Code run in a sub thread!");
}
}
public class CreateThreadTester {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
Runnable command = new Worker();
service.execute(command);
}
}
Executors 的工具类可以创建三种类型的普通线程池：
固定大小的线程池：Executors.newFixedThreadPool(n)
单线程池：Executors.newSingleThreadExecutor()
缓存线程池：Executors.newCachedThreadPool()
当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程。 适用于提交短期的异步小程序，以及负载较轻的服务器，而负载相对较重的服务器应使用固定大小的线程池。
6、Spring中使用@EnableAsync和@Async注解
在pom.xml文件中配置spring-boot-starter依赖：
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.2.1.RELEASE</version>
</dependency>
示例代码如下：
import java.util.concurrent.Executor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
@Service
class AsyncService {
@Async
public void testAsync_1() {
System.out.println("testAsync_1 is running, thread :" + Thread.currentThread().getName());
}
@Async
public void testAsync_2() {
System.out.println("testAsync_2 is running, thread :" + Thread.currentThread().getName());
}
}
@Configuration
@ComponentScan("com.tang.spring")
@EnableAsync
class Config implements AsyncConfigurer {
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setCorePoolSize(2);
taskExecutor.setMaxPoolSize(2);
taskExecutor.setQueueCapacity(2);
taskExecutor.initialize();
return taskExecutor;
}
}
public class SpringApplicationTester {
public static void main(String[] args) {
AbstractApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
AsyncService bean = context.getBean(AsyncService.class);
bean.testAsync_1();
bean.testAsync_2();
}
}
今天就先介绍到这里，后面继续整理，持续更新。。。
来源：产品经理
原文地址：https://www.cnblogs.com/1994july/p/12324640.html