多线程创建的几种方式?
创建多线程目前有4种方式,分别是通过继承Thread类来创建多线程,通过实现Runnable接口来创建多线程,通过实现Callable接口来创建多线程,通过线程池来创建多线程。
通过Thread的子类创建多线程
通过继承Thread类,并重写run()方法,来创建多线程。开启一个新的线程需要调用start()方法,而不是调用run()方法,开启后,线程并不一定立刻执行,而是由新建状态,变为就绪状态,如果此时刚好被分配到CPU的执行权,那么就由就绪状态转为运行状态,运行状态中,可能会发生线程阻塞,即由运行状态转为阻塞状态,让线程进入阻塞状态,可以调用wait()方法、sleep(long millis)方法、join()方法、suspend()方法、等待同步锁。如果没有发生线程阻塞,那么线程运行完成后,最终会变为死亡状态。
所以多线程一共涉及五种状态:新建状态、就绪状态、运行状态、阻塞状态、死亡状态。五种状态之间的转换关系如图。
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
// 创建线程的子类对象
MyThread myThread = new MyThread();
// 调用start(),启动该线程
myThread.start();
// 如下操作仍然是在main线程中执行
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(i + "main()");
}
}
}
}
通过实现Runnable接口创建多线程
由于通过Java是单继承的,所以当我们使用第一种方式,也就是通过继承Thread类来创建多线程时,不利于扩展,Thread的子类不能再继承其它类,所以我们一般开发种很少使用第一种方式,而是通过实现Runnable接口的方式创建多线程。也是一样的,需要覆盖Runnable接口中的run()方法,把正真要操作的数据放到run()方法中。具体代码如下。
class Window implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(ticket--);
}else {
break;
}
}
}
}
public class WindowsTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
t1.setName("窗口1");
t1.start();
Thread t2 = new Thread(w);
t2.setName("窗口2");
t2.start();
}
}
开启线程也是调用Thread中的start()方法,所以虽然是通过Runnable的实现类创建多线程,但是实际上也是要通过调用Thread类中的方法和构造器实现的。从上面的代码中可以看到,我们创建Runnable接口的实现类对象之后,通过参数的形式传递到Thread类中的构造器中,并且使线程由新建状态转为就绪状态需要调用Thread类中的start()方法。
通过实现Callable接口创建多线程
通过实现Callable接口的方式创建多线比较复杂,有很多新手朋友们不懂,其实我也记得这个创建过程,确实过程比较复杂,要多练习。
Callable可以类比Runnable,实现Runnable接口,必须覆盖run()方法,那么实现Callable接口,我们需要覆盖的不是run()方法了,而是覆盖call()方法,这也很容易类比到。
通过实现Callable接口的方式创建的线程,可以有返回值,这与前两种方式不同。并且返回值必须要通过Future Task类来获取。也支持泛型,支持抛出异常。具体代码如下。
class NumberThread implements Callable {
// 实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class CallableTest {
public static void main(String[] args) {
// 创建Callable接口实现类的对象
NumberThread numberThread = new NumberThread();
// 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask的对象。
FutureTask futureTask = new FutureTask(numberThread);
// 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
try {
// 获取Callable中call()的返回值
// get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为:" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
总结一下:实现Callable接口的方式创建的多线程,可以有返回值,可以抛出异常,可以使用泛型,功能比Runnable更强大。但是也是必须要使用到Thread类,也是通过调用Thread类中的构造器把Callable接口的实现类传递进去,并且开启一下线程,也是通过调用Thread类中的start()方法。
通过线程池创建多线程
通过线程池创建多线程的方式是开发中最常用的,这可以减少因频繁的创建线程和销毁线程消耗掉大量的服务器性能。线程池刚好可以避免这些问题。
首先来看一下线程池如果来创建线程。
package top.lukeewin.java1;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @author Luke Ewin
* @create 2022-06-18 13:34
*/
class NumberThread1 implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumberThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1. 提供指定线程数的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// System.out.println(service.getClass()); // java.util.concurrent.ThreadPoolExecutor
ThreadPoolExecutor server1 = (ThreadPoolExecutor) service;
// server1.setCorePoolSize(15);
// 2. 执行指定的线程d的操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread1()); // 适合使用于Runnable
service.execute(new NumberThread2()); // 适合使用于Runnable
// service.submit(); // 适合使用于Callable
// 关闭连接池
service.shutdown();
}
}
我们可以通过调用Executors类中的静态方法,来返回一个线程池,有四种不同的线程池,当调用newFixedThreadPool()方法时,则返回一个固定数量的线程池,并且可以通过形参的方式设置线程池中线程的数量。当调用newSingleThreadExecutor()方法,返回一个单线程化的线程池。当调用newScheduledThreadPool()可以返回一个定时的线程池。当调用newCachedThreadPool()可以返回一个可缓存的线程池。