老生常谈的问题:你说一说 Java 创建线程都有哪些方式?
Java 创建线程有两种方式:
-
继承Thread类,并重写run()方法
-
实现Runnable接口,覆盖接口中的run()方法,并把Runnable接口的实现扔给Thread
代码实现以下:
```java
public static void main(String[] args) {
// 第一种
MyThread myThread = new MyThread();
myThread.start();
// 第二种
new Thread(() -> System.out.println("自己实现的run-2")).start();
}
public static class MyThread extends Thread {
@Override
public void run() {
System.out.println("自己实现的run-1");
}
}
**下面说说想不到另外2种:**
# **1. 覆写Callable接口实现多线程**
(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
(2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。(FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了Future和Runnable接口。)
(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
```java
```java
代码实现:
package com.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableThreadTest implements Callable<Integer>
{
public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值:"+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}
}
@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}
# **2.通过线程池来创建线程**
(1)Executors提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。
(2) public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
(3)public static ExecutorService newCachedThreadPool()创建一个可缓存的线程池,调用execute将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线 程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
(4) public static ExecutorService newSingleThreadExecutor()创建一个单线程化的Executor。
(5)public static ScheduledExecutorService newScheduledThreadPool(int
corePoolSize)创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
```java
代码实现:
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class MyThreadPool {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<Runnable>(20));
Future task;
for (int i = 0; i < 5; i++) {
task = executor.submit(new CallableImpl());
System.out.println("线程返回结果:" + task.get());
}
executor.shutdown();
}
}
class RunnableImpl implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("hhh");
System.out.println(Thread.currentThread().getName());
}
}
注意:常用的是前3种接口创建线程