在Java中,创建线程是一项非常重要的任务。线程是一种轻量级的子进程,可以并行执行,使得程序的执行效率得到提高。Java提供了多种方式来创建线程,但许多人都认为Java有三种创建线程的方式,它们分别是继承Thread类、实现Runnable接口和使用线程池。
但是,你们知道吗?其实在创建线程的过程中,除了上述描述的方法还有很多种方式可以选择哦。今天,我们就来揭开这个惊天秘密,一起来了解一下Java并发编程中创建线程的八股文。
一. 创建线程的方法:
1. 继承Thread类创建线程
这是最基本的创建线程的方式,我们可以通过继承Thread类来创建一个自定义的线程类,然后重写run()方法,实现线程的逻辑。
public class MyThread extends Thread {
@Override
public void run() {
// 线程逻辑
}
}
// 创建并启动线程
MyThread myThread = new MyThread();
myThread.start();
2. 实现Runnable接口创建线程
这是另一种常见的创建线程的方式,我们可以通过实现Runnable接口来创建一个自定义的线程类,然后将该类实例化并传递给Thread类的构造方法中,最后调用start()方法启动线程。
public class MyRunnable implements Runnable {
@Override
public void run() {
// 线程逻辑
}
}
// 创建并启动线程
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
3. 实现Callable接口创建线程
Callable接口与Runnable接口类似,但是它可以返回一个结果并抛出异常。我们可以通过实现Callable接口来创建一个自定义的线程类,然后将该类实例化并传递给FutureTask类的构造方法中,最后调用start()方法启动线程。
public class MyCallable implements Callable {
@Override
public String call() throws Exception {
// 线程逻辑
return "result";
}
}
// 创建并启动线程
MyCallable myCallable = new MyCallable();
FutureTask futureTask = new FutureTask<>(myCallable);
Thread thread = new Thread(futureTask);
thread.start();
// 获取线程返回结果
String result = futureTask.get();
4. 使用线程池创建线程
线程池是一种重用线程的机制,可以减少线程创建和销毁的开销。我们可以通过Executors类提供的静态方法来创建不同类型的线程池,然后将任务提交给线程池执行。
ExecutorService executorService = Executors.newFixedThreadPool(10);
// 提交任务并执行
executorService.submit(new Runnable() {
@Override
public void run() {
// 线程逻辑
}
});
// 关闭线程池
executorService.shutdown();
5. 使用定时器创建线程
定时器可以用来定时执行某个任务。我们可以通过Timer类来创建一个定时器,然后将任务添加到定时器中执行。
6. 使用ScheduledExecutorService创建线程
ScheduledExecutorService
是一种可以调度任务执行的线程池。我们可以通过它来创建一个定时任务,也可以创建一个周期性任务。
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
// 创建定时任务并执行
scheduledExecutorService.schedule(new Runnable() {
@Override
public void run() {
// 线程逻辑
}
}, 1, TimeUnit.SECONDS);
// 创建周期性任务并执行
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
// 线程逻辑
}
}, 1, 1, TimeUnit.SECONDS);
// 关闭线程池
scheduledExecutorService.shutdown();
7. 使用Fork/Join框架创建线程
Fork/Join框架是Java 7中引入的一种并行执行任务的机制。它可以将一个大任务拆分成多个小任务并行执行,最后将结果合并。
public class MyTask extends RecursiveTask {
private int start;
private int end;
public MyTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if (end - start <= 1000) {
// 执行小任务
return 0;
} else {
// 拆分大任务
int mid = (start + end) / 2;
MyTask leftTask = new MyTask(start, mid);
MyTask rightTask = new MyTask(mid + 1, end);
leftTask.fork();
rightTask.fork();
// 合并结果
return leftTask.join() + rightTask.join();
}
}
}
// 创建并执行任务
ForkJoinPool forkJoinPool = new ForkJoinPool();
MyTask myTask = new MyTask(1, 10000);
int result = forkJoinPool.invoke(myTask);
8. 使用Semaphore创建线程
Semaphore是一种计数器,用来控制同时访问某个资源的线程数量。我们可以通过Semaphore来创建一个有限的线程池。
Semaphore semaphore = new Semaphore(10);
// 创建并执行任务
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
semaphore.acquire();
// 线程逻辑
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}