Java——创建多线程的四种方式
一、继承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()->设置线程任务类似runpublic 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 接口可用于需要获取线程执行结果的场景；使用线程池则可以高效地管理和复用线程，适用于需要大量线程处理任务的情况，并且可以通过合理配置线程池参数来优化系统性能。在实际开发中，需要根据具体的需求和场景选择合适的多线程创建方式，以充分发挥多线程编程的优势，提高程序的质量和效率。