一、继承Thread
步骤
1.定义一个类继承Thread
2.重写run方法，在方法中设置线程任务（此线程具体执行的代码）
3.创建自定义线程类对象
4.调用Thread中的start方法，开启线程，jvm自动调用run方法
常用方法
void start()->开启线程，jvm自动调用run方法
void run()->设置线程任务，Thread重写接口Runnable中的run方法
String getName()->获取线程名字
void setName()->给线程设置名字
static Thread currentThread()->获取正在执行的线程对象
static void sleep(long millis)->线程睡眠，睡醒后自动继续执行。示例代码
public class Person extends Thread{
public void run() {
for(int i=0;i<5;i++){
System.out.println(i);
}
}
}
public class Demon1 {
public static void main(String[] args) throws LogeinException {
Person p=new Person();
p.start();
for(int i=0;i<5;i++){
System.out.println("main"+i);
}
}
}
二、实现Runnable接口
步骤
1.创建一个类实现Runnable接口
2.重写run方法，设置线程任务
3.利用Thread类的构造方法：Thread(Runnable target),创建Thread对象（线程对象），将自定义的类当参数传递到Thread构造中
4.调用Thread中的start方法，开启线程，jvm自动调用run方法
示例代码
public class MyThread implements Runnable{
public void run() {
for(int i=1;i<10;i++){
System.out.println(Thread.currentThread().getName()+i);
Thread.yield();
}
}
}
public class Demon1 {
public static void main(String[] args) throws LogeinException {
MyThread myThread = new MyThread();
Thread t1=new Thread(myThread);
t1.start();
}
}
匿名内部类创建多线程
匿名内部类形式建立在实现Runnable接口的基础上完成
public class Demon1 {
public static void main(String[] args) throws LogeinException {
new Thread(new Runnable() {
public void run() {
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+i);
}
}
}).start();
}
}
//Thread(Runnable target,String name)：name代表线程的名字
public class Demon1 {
public static void main(String[] args) throws LogeinException {
new Thread(new Runnable() {
public void run() {
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+i);
}
}
},"m-").start();
}
}
以上两种多线程的方式区别
1.继承Thread：继承只支持单继承，有继承的局限性
2.实现Runnable：没有继承的局限性
三、实现Callable接口
Callable是一个接口<V>，类似Runnable
步骤
1.创建一个类实现 Callable 接口，该接口是一个函数式接口，有一个泛型参数，用于指定返回值类型。
2.实现 call 方法，在 call 方法中定义线程要执行的任务，并返回一个结果。
3.创建 Callable 接口实现类的实例，将其包装在一个 FutureTask 对象中，FutureTask 实现了 RunnableFuture 接口，而 RunnableFuture 接口继承了 Runnable 和 Future 接口。
4.将 FutureTask 对象作为参数传递给 Thread 类的构造函数，然后调用 start 方法启动线程。可以通过 FutureTask 的 get 方法获取 call 方法的返回结果。
V call()->设置线程任务类似run
public class MyTicket implements Callable<String> {
public String call() throws Exception {
return null;
}
}
call和run的区别：
a.相同点：设置线程任务
b.不同点：call有返回值，有异常可以throws；run方法没有返回值，有异常不可以throw
获取call方法返回值：FutureTask<V>
a.FutureTask<V>实现了一个接口：Future<V>
b.FutureTask<V>中有一个方法：
V get()->获取call方法的返回值
示例代码
public class Text {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyTicket myTicket = new MyTicket();
FutureTask<String> future = new FutureTask<>(myTicket);
//创建Thread对象->Thread(Runnable target)
Thread thread=new Thread(future);
thread.start();
//调用get方法获取call方法返回值
System.out.println(future.get());
}
}四、线程池
步骤
1.创建线程池对象，指定池子中最多有多少个线程对象;
2.每来一个线程任务，判断线程池中有没有线程对象，如果没有，创建线程对象，给线程任务用，用完需要返还给线程池；创建的线程对象数量不能超过指定的线程对象数量；如果此时没有空闲的线程对象，需要等待其它线程任务执行完毕再使用
- 如何创建线程池对象：工具类->Executors
- 获取线程池对象：Executors中的静态方法：
static ExecutorService newFixedThreadPool(int nThreads)
a.参数：指定线程池中最多创建的线程对象；
b.返回值ExecutorService是线程池，用来管理线程对象- 执行线程任务：ExcutorService中的方法
Future<?>submit(Runnable task) 提交一个Runnable任务用于执行
Future<T> submit(Callable<T> task) 提交一个Callable任务用于执行- submit的返回值：Future接口，用于接收run方法或call方法的返回值，但是run方法没有返回值，所以可以不用Future接收，执行call方法需要用Future接收。Future中有一个方法：V get()用于获取call方法返回值
- ExcutorService中的方法
void shutdown() 启动有序关闭，其中先前提交的任务将被执行，但不会接收任何新任务示例代码
public class MyTicket implements Runnable {
public void run(){
System.out.println(Thread.currentThread().getName()+"run");
}
}
public class Text {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建线程池对象
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(new MyTicket());
executor.submit(new MyTicket());
executor.submit(new MyTicket());
executor.shutdown();//关闭线程对象
}
}public class MyTicket implements Callable<Integer> {
public Integer call() throws Exception {
return 1;
}
}
public class Text {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建线程池对象
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Integer> f1=executor.submit(new MyTicket());
System.out.println(f1.get());
Future<Integer>f2=executor.submit(new MyTicket());
System.out.println(f2.get());
executor.submit(new MyTicket());
executor.shutdown();//关闭线程对象
}
}
五、总结
Java 提供了多种创建多线程的方式，每种方式都有其特点和适用场景。继承 Thread 类简单直接，适用于简单的线程任务；实现 Runnable 接口更加灵活，适合在已有类层次结构中使用多线程；实现 Callable 接口可用于需要获取线程执行结果的场景；使用线程池则可以高效地管理和复用线程，适用于需要大量线程处理任务的情况，并且可以通过合理配置线程池参数来优化系统性能。在实际开发中，需要根据具体的需求和场景选择合适的多线程创建方式，以充分发挥多线程编程的优势，提高程序的质量和效率。